2022-01-25 19:52:58 +00:00
|
|
|
package coderd_test
|
|
|
|
|
|
|
|
import (
|
|
|
|
"context"
|
2022-04-07 09:03:35 +00:00
|
|
|
"fmt"
|
2022-02-06 00:24:51 +00:00
|
|
|
"net/http"
|
2022-01-25 19:52:58 +00:00
|
|
|
"testing"
|
2022-04-07 09:03:35 +00:00
|
|
|
"time"
|
2022-01-25 19:52:58 +00:00
|
|
|
|
2022-05-18 23:15:19 +00:00
|
|
|
"github.com/coder/coder/coderd/rbac"
|
|
|
|
|
2022-01-25 19:52:58 +00:00
|
|
|
"github.com/google/uuid"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
|
|
|
2022-05-11 22:03:02 +00:00
|
|
|
"github.com/coder/coder/coderd/autobuild/schedule"
|
2022-01-25 19:52:58 +00:00
|
|
|
"github.com/coder/coder/coderd/coderdtest"
|
|
|
|
"github.com/coder/coder/codersdk"
|
2022-03-07 17:40:54 +00:00
|
|
|
"github.com/coder/coder/provisioner/echo"
|
|
|
|
"github.com/coder/coder/provisionersdk/proto"
|
2022-01-25 19:52:58 +00:00
|
|
|
)
|
|
|
|
|
2022-05-19 14:29:10 +00:00
|
|
|
func TestWorkspace(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
|
|
|
|
t.Run("OK", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
client := coderdtest.New(t, nil)
|
|
|
|
user := coderdtest.CreateFirstUser(t, client)
|
|
|
|
coderdtest.NewProvisionerDaemon(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)
|
|
|
|
|
|
|
|
_, err := client.Workspace(context.Background(), workspace.ID)
|
|
|
|
require.NoError(t, err)
|
|
|
|
})
|
|
|
|
|
|
|
|
t.Run("Deleted", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
client := coderdtest.New(t, nil)
|
|
|
|
user := coderdtest.CreateFirstUser(t, client)
|
|
|
|
coderdtest.NewProvisionerDaemon(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)
|
|
|
|
|
|
|
|
// Getting with deleted=true should fail.
|
|
|
|
_, err := client.DeletedWorkspace(context.Background(), workspace.ID)
|
|
|
|
require.Error(t, err)
|
|
|
|
require.ErrorContains(t, err, "400") // bad request
|
|
|
|
|
|
|
|
// Delete the workspace
|
|
|
|
build, err := client.CreateWorkspaceBuild(context.Background(), workspace.ID, codersdk.CreateWorkspaceBuildRequest{
|
2022-05-19 18:04:44 +00:00
|
|
|
Transition: codersdk.WorkspaceTransitionDelete,
|
2022-05-19 14:29:10 +00:00
|
|
|
})
|
|
|
|
require.NoError(t, err, "delete the workspace")
|
|
|
|
coderdtest.AwaitWorkspaceBuildJob(t, client, build.ID)
|
|
|
|
|
|
|
|
// Getting with deleted=true should work.
|
|
|
|
workspaceNew, err := client.DeletedWorkspace(context.Background(), workspace.ID)
|
|
|
|
require.NoError(t, err)
|
|
|
|
require.Equal(t, workspace.ID, workspaceNew.ID)
|
|
|
|
|
|
|
|
// Getting with deleted=false should not work.
|
|
|
|
_, err = client.Workspace(context.Background(), workspace.ID)
|
|
|
|
require.Error(t, err)
|
|
|
|
require.ErrorContains(t, err, "410") // gone
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2022-05-18 23:15:19 +00:00
|
|
|
func TestAdminViewAllWorkspaces(t *testing.T) {
|
2022-01-25 19:52:58 +00:00
|
|
|
t.Parallel()
|
2022-03-07 17:40:54 +00:00
|
|
|
client := coderdtest.New(t, nil)
|
|
|
|
user := coderdtest.CreateFirstUser(t, client)
|
2022-03-22 19:17:50 +00:00
|
|
|
coderdtest.NewProvisionerDaemon(t, client)
|
2022-04-06 17:42:40 +00:00
|
|
|
version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)
|
|
|
|
coderdtest.AwaitTemplateVersionJob(t, client, version.ID)
|
|
|
|
template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)
|
2022-04-25 21:11:03 +00:00
|
|
|
workspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)
|
2022-05-18 23:15:19 +00:00
|
|
|
coderdtest.AwaitWorkspaceBuildJob(t, client, workspace.LatestBuild.ID)
|
2022-03-07 17:40:54 +00:00
|
|
|
_, err := client.Workspace(context.Background(), workspace.ID)
|
|
|
|
require.NoError(t, err)
|
2022-05-18 23:15:19 +00:00
|
|
|
|
|
|
|
otherOrg, err := client.CreateOrganization(context.Background(), codersdk.Me, 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.
|
|
|
|
other := coderdtest.CreateAnotherUser(t, client, otherOrg.ID, rbac.RoleAdmin(), rbac.RoleMember())
|
|
|
|
otherWorkspaces, err := other.Workspaces(context.Background(), codersdk.WorkspaceFilter{})
|
|
|
|
require.NoError(t, err, "(other) fetch workspaces")
|
|
|
|
|
|
|
|
firstWorkspaces, err := other.Workspaces(context.Background(), codersdk.WorkspaceFilter{})
|
|
|
|
require.NoError(t, err, "(first) fetch workspaces")
|
|
|
|
|
|
|
|
require.ElementsMatch(t, otherWorkspaces, firstWorkspaces)
|
2022-02-06 00:24:51 +00:00
|
|
|
}
|
2022-01-25 19:52:58 +00:00
|
|
|
|
2022-05-16 19:36:27 +00:00
|
|
|
func TestPostWorkspacesByOrganization(t *testing.T) {
|
2022-03-22 19:17:50 +00:00
|
|
|
t.Parallel()
|
2022-05-16 19:36:27 +00:00
|
|
|
t.Run("InvalidTemplate", func(t *testing.T) {
|
2022-03-22 19:17:50 +00:00
|
|
|
t.Parallel()
|
|
|
|
client := coderdtest.New(t, nil)
|
|
|
|
user := coderdtest.CreateFirstUser(t, client)
|
2022-05-16 19:36:27 +00:00
|
|
|
_, err := client.CreateWorkspace(context.Background(), user.OrganizationID, 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)
|
|
|
|
|
2022-05-18 23:15:19 +00:00
|
|
|
other := coderdtest.CreateAnotherUser(t, client, first.OrganizationID, rbac.RoleMember(), rbac.RoleAdmin())
|
2022-05-16 19:36:27 +00:00
|
|
|
org, err := other.CreateOrganization(context.Background(), codersdk.Me, 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(context.Background(), first.OrganizationID, 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, nil)
|
|
|
|
coderdtest.NewProvisionerDaemon(t, client)
|
|
|
|
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)
|
|
|
|
_, err := client.CreateWorkspace(context.Background(), user.OrganizationID, 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()
|
|
|
|
client := coderdtest.New(t, nil)
|
2022-03-22 19:17:50 +00:00
|
|
|
coderdtest.NewProvisionerDaemon(t, client)
|
2022-05-16 19:36:27 +00:00
|
|
|
user := coderdtest.CreateFirstUser(t, client)
|
2022-04-06 17:42:40 +00:00
|
|
|
version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)
|
|
|
|
template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)
|
|
|
|
coderdtest.AwaitTemplateVersionJob(t, client, version.ID)
|
2022-05-16 19:36:27 +00:00
|
|
|
_ = coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestWorkspacesByOrganization(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
t.Run("ListEmpty", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
client := coderdtest.New(t, nil)
|
|
|
|
user := coderdtest.CreateFirstUser(t, client)
|
|
|
|
_, err := client.WorkspacesByOrganization(context.Background(), user.OrganizationID)
|
|
|
|
require.NoError(t, err)
|
|
|
|
})
|
|
|
|
t.Run("List", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
client := coderdtest.New(t, nil)
|
|
|
|
coderdtest.NewProvisionerDaemon(t, client)
|
|
|
|
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)
|
|
|
|
workspaces, err := client.WorkspacesByOrganization(context.Background(), user.OrganizationID)
|
|
|
|
require.NoError(t, err)
|
|
|
|
require.Len(t, workspaces, 1)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestWorkspacesByOwner(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
t.Run("ListEmpty", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
client := coderdtest.New(t, nil)
|
|
|
|
user := coderdtest.CreateFirstUser(t, client)
|
|
|
|
_, err := client.WorkspacesByOwner(context.Background(), user.OrganizationID, codersdk.Me)
|
|
|
|
require.NoError(t, err)
|
|
|
|
})
|
2022-05-18 15:09:07 +00:00
|
|
|
|
|
|
|
t.Run("ListMine", func(t *testing.T) {
|
2022-05-16 19:36:27 +00:00
|
|
|
t.Parallel()
|
|
|
|
client := coderdtest.New(t, nil)
|
|
|
|
coderdtest.NewProvisionerDaemon(t, client)
|
|
|
|
user := coderdtest.CreateFirstUser(t, client)
|
2022-05-18 15:09:07 +00:00
|
|
|
me, err := client.User(context.Background(), codersdk.Me)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
2022-05-16 19:36:27 +00:00
|
|
|
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)
|
2022-05-18 15:09:07 +00:00
|
|
|
|
|
|
|
// Create noise workspace that should be filtered out
|
|
|
|
other := coderdtest.CreateAnotherUser(t, client, user.OrganizationID)
|
|
|
|
_ = coderdtest.CreateWorkspace(t, other, user.OrganizationID, template.ID)
|
|
|
|
|
|
|
|
// Use a username
|
|
|
|
workspaces, err := client.Workspaces(context.Background(), codersdk.WorkspaceFilter{
|
|
|
|
OrganizationID: user.OrganizationID,
|
|
|
|
Owner: me.Username,
|
|
|
|
})
|
2022-05-16 19:36:27 +00:00
|
|
|
require.NoError(t, err)
|
|
|
|
require.Len(t, workspaces, 1)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestWorkspaceByOwnerAndName(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
t.Run("NotFound", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
client := coderdtest.New(t, nil)
|
|
|
|
user := coderdtest.CreateFirstUser(t, client)
|
|
|
|
_, err := client.WorkspaceByOwnerAndName(context.Background(), user.OrganizationID, codersdk.Me, "something")
|
|
|
|
var apiErr *codersdk.Error
|
|
|
|
require.ErrorAs(t, err, &apiErr)
|
2022-05-17 18:43:19 +00:00
|
|
|
require.Equal(t, http.StatusForbidden, apiErr.StatusCode())
|
2022-05-16 19:36:27 +00:00
|
|
|
})
|
|
|
|
t.Run("Get", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
client := coderdtest.New(t, nil)
|
|
|
|
coderdtest.NewProvisionerDaemon(t, client)
|
|
|
|
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)
|
2022-04-25 21:11:03 +00:00
|
|
|
workspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)
|
2022-05-16 19:36:27 +00:00
|
|
|
_, err := client.WorkspaceByOwnerAndName(context.Background(), user.OrganizationID, codersdk.Me, workspace.Name)
|
2022-03-22 19:17:50 +00:00
|
|
|
require.NoError(t, err)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2022-03-07 17:40:54 +00:00
|
|
|
func TestPostWorkspaceBuild(t *testing.T) {
|
2022-02-06 00:24:51 +00:00
|
|
|
t.Parallel()
|
2022-04-06 17:42:40 +00:00
|
|
|
t.Run("NoTemplateVersion", func(t *testing.T) {
|
2022-01-25 19:52:58 +00:00
|
|
|
t.Parallel()
|
2022-02-21 20:36:29 +00:00
|
|
|
client := coderdtest.New(t, nil)
|
2022-03-22 19:17:50 +00:00
|
|
|
coderdtest.NewProvisionerDaemon(t, client)
|
2022-03-07 17:40:54 +00:00
|
|
|
user := coderdtest.CreateFirstUser(t, client)
|
2022-04-06 17:42:40 +00:00
|
|
|
version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)
|
|
|
|
template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)
|
|
|
|
coderdtest.AwaitTemplateVersionJob(t, client, version.ID)
|
2022-04-25 21:11:03 +00:00
|
|
|
workspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)
|
2022-03-22 19:17:50 +00:00
|
|
|
_, err := client.CreateWorkspaceBuild(context.Background(), workspace.ID, codersdk.CreateWorkspaceBuildRequest{
|
2022-04-06 17:42:40 +00:00
|
|
|
TemplateVersionID: uuid.New(),
|
2022-05-19 18:04:44 +00:00
|
|
|
Transition: codersdk.WorkspaceTransitionStart,
|
2022-01-25 19:52:58 +00:00
|
|
|
})
|
2022-02-06 00:24:51 +00:00
|
|
|
require.Error(t, err)
|
|
|
|
var apiErr *codersdk.Error
|
|
|
|
require.ErrorAs(t, err, &apiErr)
|
|
|
|
require.Equal(t, http.StatusBadRequest, apiErr.StatusCode())
|
2022-01-25 19:52:58 +00:00
|
|
|
})
|
|
|
|
|
2022-04-06 17:42:40 +00:00
|
|
|
t.Run("TemplateVersionFailedImport", func(t *testing.T) {
|
2022-01-25 19:52:58 +00:00
|
|
|
t.Parallel()
|
2022-02-21 20:36:29 +00:00
|
|
|
client := coderdtest.New(t, nil)
|
2022-03-07 17:40:54 +00:00
|
|
|
user := coderdtest.CreateFirstUser(t, client)
|
|
|
|
coderdtest.NewProvisionerDaemon(t, client)
|
2022-04-06 17:42:40 +00:00
|
|
|
version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, &echo.Responses{
|
2022-03-07 17:40:54 +00:00
|
|
|
Provision: []*proto.Provision_Response{{}},
|
2022-01-25 19:52:58 +00:00
|
|
|
})
|
2022-04-06 17:42:40 +00:00
|
|
|
template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)
|
|
|
|
coderdtest.AwaitTemplateVersionJob(t, client, version.ID)
|
2022-04-25 21:11:03 +00:00
|
|
|
_, err := client.CreateWorkspace(context.Background(), user.OrganizationID, codersdk.CreateWorkspaceRequest{
|
2022-04-06 17:42:40 +00:00
|
|
|
TemplateID: template.ID,
|
|
|
|
Name: "workspace",
|
2022-01-25 19:52:58 +00:00
|
|
|
})
|
2022-02-06 00:24:51 +00:00
|
|
|
var apiErr *codersdk.Error
|
|
|
|
require.ErrorAs(t, err, &apiErr)
|
2022-03-07 17:40:54 +00:00
|
|
|
require.Equal(t, http.StatusPreconditionFailed, apiErr.StatusCode())
|
2022-01-25 19:52:58 +00:00
|
|
|
})
|
|
|
|
|
2022-03-07 17:40:54 +00:00
|
|
|
t.Run("AlreadyActive", func(t *testing.T) {
|
2022-01-25 19:52:58 +00:00
|
|
|
t.Parallel()
|
2022-02-21 20:36:29 +00:00
|
|
|
client := coderdtest.New(t, nil)
|
2022-03-07 17:40:54 +00:00
|
|
|
user := coderdtest.CreateFirstUser(t, client)
|
|
|
|
closeDaemon := coderdtest.NewProvisionerDaemon(t, client)
|
2022-04-06 17:42:40 +00:00
|
|
|
version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)
|
|
|
|
template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)
|
|
|
|
coderdtest.AwaitTemplateVersionJob(t, client, version.ID)
|
2022-03-07 17:40:54 +00:00
|
|
|
// Close here so workspace build doesn't process!
|
|
|
|
closeDaemon.Close()
|
2022-04-25 21:11:03 +00:00
|
|
|
workspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)
|
2022-03-22 19:17:50 +00:00
|
|
|
_, err := client.CreateWorkspaceBuild(context.Background(), workspace.ID, codersdk.CreateWorkspaceBuildRequest{
|
2022-04-06 17:42:40 +00:00
|
|
|
TemplateVersionID: template.ActiveVersionID,
|
2022-05-19 18:04:44 +00:00
|
|
|
Transition: codersdk.WorkspaceTransitionStart,
|
2022-01-25 19:52:58 +00:00
|
|
|
})
|
|
|
|
require.Error(t, err)
|
2022-02-06 00:24:51 +00:00
|
|
|
var apiErr *codersdk.Error
|
|
|
|
require.ErrorAs(t, err, &apiErr)
|
|
|
|
require.Equal(t, http.StatusConflict, apiErr.StatusCode())
|
2022-01-25 19:52:58 +00:00
|
|
|
})
|
|
|
|
|
2022-05-18 16:33:33 +00:00
|
|
|
t.Run("IncrementBuildNumber", func(t *testing.T) {
|
2022-01-25 19:52:58 +00:00
|
|
|
t.Parallel()
|
2022-02-21 20:36:29 +00:00
|
|
|
client := coderdtest.New(t, nil)
|
2022-03-07 17:40:54 +00:00
|
|
|
user := coderdtest.CreateFirstUser(t, client)
|
|
|
|
coderdtest.NewProvisionerDaemon(t, client)
|
2022-04-06 17:42:40 +00:00
|
|
|
version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)
|
|
|
|
template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)
|
|
|
|
coderdtest.AwaitTemplateVersionJob(t, client, version.ID)
|
2022-04-25 21:11:03 +00:00
|
|
|
workspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)
|
2022-03-22 19:17:50 +00:00
|
|
|
coderdtest.AwaitWorkspaceBuildJob(t, client, workspace.LatestBuild.ID)
|
|
|
|
build, err := client.CreateWorkspaceBuild(context.Background(), workspace.ID, codersdk.CreateWorkspaceBuildRequest{
|
2022-04-06 17:42:40 +00:00
|
|
|
TemplateVersionID: template.ActiveVersionID,
|
2022-05-19 18:04:44 +00:00
|
|
|
Transition: codersdk.WorkspaceTransitionStart,
|
2022-03-07 17:40:54 +00:00
|
|
|
})
|
|
|
|
require.NoError(t, err)
|
2022-05-18 16:33:33 +00:00
|
|
|
require.Equal(t, workspace.LatestBuild.BuildNumber+1, build.BuildNumber)
|
2022-01-25 19:52:58 +00:00
|
|
|
})
|
|
|
|
|
2022-05-02 22:51:58 +00:00
|
|
|
t.Run("WithState", func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
client := coderdtest.New(t, nil)
|
|
|
|
user := coderdtest.CreateFirstUser(t, client)
|
|
|
|
closeDaemon := coderdtest.NewProvisionerDaemon(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)
|
|
|
|
coderdtest.AwaitWorkspaceBuildJob(t, client, workspace.LatestBuild.ID)
|
|
|
|
_ = closeDaemon.Close()
|
|
|
|
wantState := []byte("something")
|
|
|
|
build, err := client.CreateWorkspaceBuild(context.Background(), workspace.ID, codersdk.CreateWorkspaceBuildRequest{
|
|
|
|
TemplateVersionID: template.ActiveVersionID,
|
2022-05-19 18:04:44 +00:00
|
|
|
Transition: codersdk.WorkspaceTransitionStart,
|
2022-05-02 22:51:58 +00:00
|
|
|
ProvisionerState: wantState,
|
|
|
|
})
|
|
|
|
require.NoError(t, err)
|
|
|
|
gotState, err := client.WorkspaceBuildState(context.Background(), build.ID)
|
|
|
|
require.NoError(t, err)
|
|
|
|
require.Equal(t, wantState, gotState)
|
|
|
|
})
|
|
|
|
|
2022-03-22 19:17:50 +00:00
|
|
|
t.Run("Delete", func(t *testing.T) {
|
2022-03-07 17:40:54 +00:00
|
|
|
t.Parallel()
|
|
|
|
client := coderdtest.New(t, nil)
|
|
|
|
user := coderdtest.CreateFirstUser(t, client)
|
|
|
|
coderdtest.NewProvisionerDaemon(t, client)
|
2022-04-06 17:42:40 +00:00
|
|
|
version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)
|
|
|
|
template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)
|
|
|
|
coderdtest.AwaitTemplateVersionJob(t, client, version.ID)
|
2022-04-25 21:11:03 +00:00
|
|
|
workspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)
|
2022-03-22 19:17:50 +00:00
|
|
|
coderdtest.AwaitWorkspaceBuildJob(t, client, workspace.LatestBuild.ID)
|
|
|
|
build, err := client.CreateWorkspaceBuild(context.Background(), workspace.ID, codersdk.CreateWorkspaceBuildRequest{
|
2022-05-19 18:04:44 +00:00
|
|
|
Transition: codersdk.WorkspaceTransitionDelete,
|
2022-03-07 17:40:54 +00:00
|
|
|
})
|
|
|
|
require.NoError(t, err)
|
2022-05-18 16:33:33 +00:00
|
|
|
require.Equal(t, workspace.LatestBuild.BuildNumber+1, build.BuildNumber)
|
2022-03-22 19:17:50 +00:00
|
|
|
coderdtest.AwaitWorkspaceBuildJob(t, client, build.ID)
|
|
|
|
|
2022-05-16 20:29:27 +00:00
|
|
|
workspaces, err := client.WorkspacesByOwner(context.Background(), user.OrganizationID, user.UserID.String())
|
2022-03-07 17:40:54 +00:00
|
|
|
require.NoError(t, err)
|
2022-03-22 19:17:50 +00:00
|
|
|
require.Len(t, workspaces, 0)
|
2022-03-07 17:40:54 +00:00
|
|
|
})
|
2022-02-06 00:24:51 +00:00
|
|
|
}
|
|
|
|
|
2022-03-07 17:40:54 +00:00
|
|
|
func TestWorkspaceBuildByName(t *testing.T) {
|
2022-02-06 00:24:51 +00:00
|
|
|
t.Parallel()
|
2022-03-07 17:40:54 +00:00
|
|
|
t.Run("NotFound", func(t *testing.T) {
|
2022-01-25 19:52:58 +00:00
|
|
|
t.Parallel()
|
2022-02-21 20:36:29 +00:00
|
|
|
client := coderdtest.New(t, nil)
|
2022-03-07 17:40:54 +00:00
|
|
|
user := coderdtest.CreateFirstUser(t, client)
|
|
|
|
coderdtest.NewProvisionerDaemon(t, client)
|
2022-04-06 17:42:40 +00:00
|
|
|
version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)
|
|
|
|
template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)
|
|
|
|
coderdtest.AwaitTemplateVersionJob(t, client, version.ID)
|
2022-04-25 21:11:03 +00:00
|
|
|
workspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)
|
2022-03-07 17:40:54 +00:00
|
|
|
_, err := client.WorkspaceBuildByName(context.Background(), workspace.ID, "something")
|
|
|
|
var apiErr *codersdk.Error
|
|
|
|
require.ErrorAs(t, err, &apiErr)
|
|
|
|
require.Equal(t, http.StatusNotFound, apiErr.StatusCode())
|
2022-01-25 19:52:58 +00:00
|
|
|
})
|
|
|
|
|
2022-03-07 17:40:54 +00:00
|
|
|
t.Run("Found", func(t *testing.T) {
|
2022-01-25 19:52:58 +00:00
|
|
|
t.Parallel()
|
2022-02-21 20:36:29 +00:00
|
|
|
client := coderdtest.New(t, nil)
|
2022-03-07 17:40:54 +00:00
|
|
|
user := coderdtest.CreateFirstUser(t, client)
|
|
|
|
coderdtest.NewProvisionerDaemon(t, client)
|
2022-04-06 17:42:40 +00:00
|
|
|
version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)
|
|
|
|
coderdtest.AwaitTemplateVersionJob(t, client, version.ID)
|
|
|
|
template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)
|
2022-04-25 21:11:03 +00:00
|
|
|
workspace := coderdtest.CreateWorkspace(t, client, user.OrganizationID, template.ID)
|
2022-03-22 19:17:50 +00:00
|
|
|
build, err := client.WorkspaceBuild(context.Background(), workspace.LatestBuild.ID)
|
2022-03-07 17:40:54 +00:00
|
|
|
require.NoError(t, err)
|
|
|
|
_, err = client.WorkspaceBuildByName(context.Background(), workspace.ID, build.Name)
|
2022-01-25 19:52:58 +00:00
|
|
|
require.NoError(t, err)
|
|
|
|
})
|
|
|
|
}
|
2022-04-07 09:03:35 +00:00
|
|
|
|
|
|
|
func TestWorkspaceUpdateAutostart(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
var dublinLoc = mustLocation(t, "Europe/Dublin")
|
|
|
|
|
|
|
|
testCases := []struct {
|
|
|
|
name string
|
|
|
|
schedule string
|
|
|
|
expectedError string
|
|
|
|
at time.Time
|
|
|
|
expectedNext time.Time
|
|
|
|
expectedInterval time.Duration
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
name: "disable autostart",
|
|
|
|
schedule: "",
|
|
|
|
expectedError: "",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "friday to monday",
|
2022-04-18 16:04:48 +00:00
|
|
|
schedule: "CRON_TZ=Europe/Dublin 30 9 * * 1-5",
|
2022-04-07 09:03:35 +00:00
|
|
|
expectedError: "",
|
|
|
|
at: time.Date(2022, 5, 6, 9, 31, 0, 0, dublinLoc),
|
|
|
|
expectedNext: time.Date(2022, 5, 9, 9, 30, 0, 0, dublinLoc),
|
|
|
|
expectedInterval: 71*time.Hour + 59*time.Minute,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "monday to tuesday",
|
2022-04-18 16:04:48 +00:00
|
|
|
schedule: "CRON_TZ=Europe/Dublin 30 9 * * 1-5",
|
2022-04-07 09:03:35 +00:00
|
|
|
expectedError: "",
|
|
|
|
at: time.Date(2022, 5, 9, 9, 31, 0, 0, dublinLoc),
|
|
|
|
expectedNext: time.Date(2022, 5, 10, 9, 30, 0, 0, dublinLoc),
|
|
|
|
expectedInterval: 23*time.Hour + 59*time.Minute,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
// DST in Ireland began on Mar 27 in 2022 at 0100. Forward 1 hour.
|
|
|
|
name: "DST start",
|
2022-04-18 16:04:48 +00:00
|
|
|
schedule: "CRON_TZ=Europe/Dublin 30 9 * * *",
|
2022-04-07 09:03:35 +00:00
|
|
|
expectedError: "",
|
|
|
|
at: time.Date(2022, 3, 26, 9, 31, 0, 0, dublinLoc),
|
|
|
|
expectedNext: time.Date(2022, 3, 27, 9, 30, 0, 0, dublinLoc),
|
|
|
|
expectedInterval: 22*time.Hour + 59*time.Minute,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
// DST in Ireland ends on Oct 30 in 2022 at 0200. Back 1 hour.
|
|
|
|
name: "DST end",
|
2022-04-18 16:04:48 +00:00
|
|
|
schedule: "CRON_TZ=Europe/Dublin 30 9 * * *",
|
2022-04-07 09:03:35 +00:00
|
|
|
expectedError: "",
|
|
|
|
at: time.Date(2022, 10, 29, 9, 31, 0, 0, dublinLoc),
|
|
|
|
expectedNext: time.Date(2022, 10, 30, 9, 30, 0, 0, dublinLoc),
|
|
|
|
expectedInterval: 24*time.Hour + 59*time.Minute,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "invalid location",
|
2022-04-18 16:04:48 +00:00
|
|
|
schedule: "CRON_TZ=Imaginary/Place 30 9 * * 1-5",
|
2022-04-07 09:03:35 +00:00
|
|
|
expectedError: "status code 500: invalid autostart schedule: parse schedule: provided bad location Imaginary/Place: unknown time zone Imaginary/Place",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "invalid schedule",
|
|
|
|
schedule: "asdf asdf asdf ",
|
2022-04-18 16:04:48 +00:00
|
|
|
expectedError: `status code 500: invalid autostart schedule: validate weekly schedule: expected schedule to consist of 5 fields with an optional CRON_TZ=<timezone> prefix`,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "only 3 values",
|
|
|
|
schedule: "CRON_TZ=Europe/Dublin 30 9 *",
|
|
|
|
expectedError: `status code 500: invalid autostart schedule: validate weekly schedule: expected schedule to consist of 5 fields with an optional CRON_TZ=<timezone> prefix`,
|
2022-04-07 09:03:35 +00:00
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, testCase := range testCases {
|
|
|
|
testCase := testCase
|
|
|
|
t.Run(testCase.name, func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
var (
|
|
|
|
ctx = context.Background()
|
|
|
|
client = coderdtest.New(t, nil)
|
|
|
|
_ = coderdtest.NewProvisionerDaemon(t, client)
|
|
|
|
user = coderdtest.CreateFirstUser(t, client)
|
|
|
|
version = coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)
|
|
|
|
_ = coderdtest.AwaitTemplateVersionJob(t, client, version.ID)
|
|
|
|
project = coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)
|
2022-04-25 21:11:03 +00:00
|
|
|
workspace = coderdtest.CreateWorkspace(t, client, user.OrganizationID, project.ID)
|
2022-04-07 09:03:35 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
// ensure test invariant: new workspaces have no autostart schedule.
|
|
|
|
require.Empty(t, workspace.AutostartSchedule, "expected newly-minted workspace to have no autostart schedule")
|
|
|
|
|
|
|
|
err := client.UpdateWorkspaceAutostart(ctx, workspace.ID, codersdk.UpdateWorkspaceAutostartRequest{
|
|
|
|
Schedule: testCase.schedule,
|
|
|
|
})
|
|
|
|
|
|
|
|
if testCase.expectedError != "" {
|
|
|
|
require.EqualError(t, err, testCase.expectedError, "unexpected error when setting workspace autostart schedule")
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
require.NoError(t, err, "expected no error setting workspace autostart schedule")
|
|
|
|
|
|
|
|
updated, err := client.Workspace(ctx, workspace.ID)
|
|
|
|
require.NoError(t, err, "fetch updated workspace")
|
|
|
|
|
|
|
|
require.Equal(t, testCase.schedule, updated.AutostartSchedule, "expected autostart schedule to equal requested")
|
|
|
|
|
|
|
|
if testCase.schedule == "" {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
sched, err := schedule.Weekly(updated.AutostartSchedule)
|
|
|
|
require.NoError(t, err, "parse returned schedule")
|
|
|
|
|
|
|
|
next := sched.Next(testCase.at)
|
|
|
|
require.Equal(t, testCase.expectedNext, next, "unexpected next scheduled autostart time")
|
|
|
|
interval := next.Sub(testCase.at)
|
|
|
|
require.Equal(t, testCase.expectedInterval, interval, "unexpected interval")
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
t.Run("NotFound", func(t *testing.T) {
|
|
|
|
var (
|
|
|
|
ctx = context.Background()
|
|
|
|
client = coderdtest.New(t, nil)
|
|
|
|
_ = coderdtest.CreateFirstUser(t, client)
|
|
|
|
wsid = uuid.New()
|
|
|
|
req = codersdk.UpdateWorkspaceAutostartRequest{
|
|
|
|
Schedule: "9 30 1-5",
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
err := client.UpdateWorkspaceAutostart(ctx, wsid, req)
|
|
|
|
require.IsType(t, err, &codersdk.Error{}, "expected codersdk.Error")
|
|
|
|
coderSDKErr, _ := err.(*codersdk.Error) //nolint:errorlint
|
|
|
|
require.Equal(t, coderSDKErr.StatusCode(), 404, "expected status code 404")
|
|
|
|
require.Equal(t, fmt.Sprintf("workspace %q does not exist", wsid), coderSDKErr.Message, "unexpected response code")
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestWorkspaceUpdateAutostop(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
var dublinLoc = mustLocation(t, "Europe/Dublin")
|
|
|
|
|
|
|
|
testCases := []struct {
|
|
|
|
name string
|
|
|
|
schedule string
|
|
|
|
expectedError string
|
|
|
|
at time.Time
|
|
|
|
expectedNext time.Time
|
|
|
|
expectedInterval time.Duration
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
name: "disable autostop",
|
|
|
|
schedule: "",
|
|
|
|
expectedError: "",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "friday to monday",
|
2022-04-18 16:04:48 +00:00
|
|
|
schedule: "CRON_TZ=Europe/Dublin 30 17 * * 1-5",
|
2022-04-07 09:03:35 +00:00
|
|
|
expectedError: "",
|
|
|
|
at: time.Date(2022, 5, 6, 17, 31, 0, 0, dublinLoc),
|
|
|
|
expectedNext: time.Date(2022, 5, 9, 17, 30, 0, 0, dublinLoc),
|
|
|
|
expectedInterval: 71*time.Hour + 59*time.Minute,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "monday to tuesday",
|
2022-04-18 16:04:48 +00:00
|
|
|
schedule: "CRON_TZ=Europe/Dublin 30 17 * * 1-5",
|
2022-04-07 09:03:35 +00:00
|
|
|
expectedError: "",
|
|
|
|
at: time.Date(2022, 5, 9, 17, 31, 0, 0, dublinLoc),
|
|
|
|
expectedNext: time.Date(2022, 5, 10, 17, 30, 0, 0, dublinLoc),
|
|
|
|
expectedInterval: 23*time.Hour + 59*time.Minute,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
// DST in Ireland began on Mar 27 in 2022 at 0100. Forward 1 hour.
|
|
|
|
name: "DST start",
|
2022-04-18 16:04:48 +00:00
|
|
|
schedule: "CRON_TZ=Europe/Dublin 30 17 * * *",
|
2022-04-07 09:03:35 +00:00
|
|
|
expectedError: "",
|
|
|
|
at: time.Date(2022, 3, 26, 17, 31, 0, 0, dublinLoc),
|
|
|
|
expectedNext: time.Date(2022, 3, 27, 17, 30, 0, 0, dublinLoc),
|
|
|
|
expectedInterval: 22*time.Hour + 59*time.Minute,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
// DST in Ireland ends on Oct 30 in 2022 at 0200. Back 1 hour.
|
|
|
|
name: "DST end",
|
2022-04-18 16:04:48 +00:00
|
|
|
schedule: "CRON_TZ=Europe/Dublin 30 17 * * *",
|
2022-04-07 09:03:35 +00:00
|
|
|
expectedError: "",
|
|
|
|
at: time.Date(2022, 10, 29, 17, 31, 0, 0, dublinLoc),
|
|
|
|
expectedNext: time.Date(2022, 10, 30, 17, 30, 0, 0, dublinLoc),
|
|
|
|
expectedInterval: 24*time.Hour + 59*time.Minute,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "invalid location",
|
2022-04-18 16:04:48 +00:00
|
|
|
schedule: "CRON_TZ=Imaginary/Place 30 17 * * 1-5",
|
2022-04-07 09:03:35 +00:00
|
|
|
expectedError: "status code 500: invalid autostop schedule: parse schedule: provided bad location Imaginary/Place: unknown time zone Imaginary/Place",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "invalid schedule",
|
|
|
|
schedule: "asdf asdf asdf ",
|
2022-04-18 16:04:48 +00:00
|
|
|
expectedError: `status code 500: invalid autostop schedule: validate weekly schedule: expected schedule to consist of 5 fields with an optional CRON_TZ=<timezone> prefix`,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "only 3 values",
|
|
|
|
schedule: "CRON_TZ=Europe/Dublin 30 9 *",
|
|
|
|
expectedError: `status code 500: invalid autostop schedule: validate weekly schedule: expected schedule to consist of 5 fields with an optional CRON_TZ=<timezone> prefix`,
|
2022-04-07 09:03:35 +00:00
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, testCase := range testCases {
|
|
|
|
testCase := testCase
|
|
|
|
t.Run(testCase.name, func(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
var (
|
|
|
|
ctx = context.Background()
|
|
|
|
client = coderdtest.New(t, nil)
|
|
|
|
_ = coderdtest.NewProvisionerDaemon(t, client)
|
|
|
|
user = coderdtest.CreateFirstUser(t, client)
|
|
|
|
version = coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, nil)
|
|
|
|
_ = coderdtest.AwaitTemplateVersionJob(t, client, version.ID)
|
|
|
|
project = coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)
|
2022-04-25 21:11:03 +00:00
|
|
|
workspace = coderdtest.CreateWorkspace(t, client, user.OrganizationID, project.ID)
|
2022-04-07 09:03:35 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
// ensure test invariant: new workspaces have no autostop schedule.
|
|
|
|
require.Empty(t, workspace.AutostopSchedule, "expected newly-minted workspace to have no autstop schedule")
|
|
|
|
|
|
|
|
err := client.UpdateWorkspaceAutostop(ctx, workspace.ID, codersdk.UpdateWorkspaceAutostopRequest{
|
|
|
|
Schedule: testCase.schedule,
|
|
|
|
})
|
|
|
|
|
|
|
|
if testCase.expectedError != "" {
|
|
|
|
require.EqualError(t, err, testCase.expectedError, "unexpected error when setting workspace autostop schedule")
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
require.NoError(t, err, "expected no error setting workspace autostop schedule")
|
|
|
|
|
|
|
|
updated, err := client.Workspace(ctx, workspace.ID)
|
|
|
|
require.NoError(t, err, "fetch updated workspace")
|
|
|
|
|
|
|
|
require.Equal(t, testCase.schedule, updated.AutostopSchedule, "expected autostop schedule to equal requested")
|
|
|
|
|
|
|
|
if testCase.schedule == "" {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
sched, err := schedule.Weekly(updated.AutostopSchedule)
|
|
|
|
require.NoError(t, err, "parse returned schedule")
|
|
|
|
|
|
|
|
next := sched.Next(testCase.at)
|
|
|
|
require.Equal(t, testCase.expectedNext, next, "unexpected next scheduled autostop time")
|
|
|
|
interval := next.Sub(testCase.at)
|
|
|
|
require.Equal(t, testCase.expectedInterval, interval, "unexpected interval")
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
t.Run("NotFound", func(t *testing.T) {
|
|
|
|
var (
|
|
|
|
ctx = context.Background()
|
|
|
|
client = coderdtest.New(t, nil)
|
|
|
|
_ = coderdtest.CreateFirstUser(t, client)
|
|
|
|
wsid = uuid.New()
|
|
|
|
req = codersdk.UpdateWorkspaceAutostopRequest{
|
|
|
|
Schedule: "9 30 1-5",
|
|
|
|
}
|
|
|
|
)
|
|
|
|
|
|
|
|
err := client.UpdateWorkspaceAutostop(ctx, wsid, req)
|
|
|
|
require.IsType(t, err, &codersdk.Error{}, "expected codersdk.Error")
|
|
|
|
coderSDKErr, _ := err.(*codersdk.Error) //nolint:errorlint
|
|
|
|
require.Equal(t, coderSDKErr.StatusCode(), 404, "expected status code 404")
|
|
|
|
require.Equal(t, fmt.Sprintf("workspace %q does not exist", wsid), coderSDKErr.Message, "unexpected response code")
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
func mustLocation(t *testing.T, location string) *time.Location {
|
|
|
|
loc, err := time.LoadLocation(location)
|
|
|
|
if err != nil {
|
|
|
|
t.Errorf("failed to load location %s: %s", location, err.Error())
|
|
|
|
}
|
|
|
|
|
|
|
|
return loc
|
|
|
|
}
|
2022-05-18 21:16:26 +00:00
|
|
|
|
|
|
|
func TestWorkspaceWatcher(t *testing.T) {
|
|
|
|
t.Parallel()
|
|
|
|
client := coderdtest.New(t, nil)
|
|
|
|
user := coderdtest.CreateFirstUser(t, client)
|
|
|
|
coderdtest.NewProvisionerDaemon(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)
|
|
|
|
w, err := client.Workspace(context.Background(), workspace.ID)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
|
|
defer cancel()
|
|
|
|
wc, err := client.WatchWorkspace(ctx, w.ID)
|
|
|
|
require.NoError(t, err)
|
|
|
|
for i := 0; i < 3; i++ {
|
|
|
|
_, more := <-wc
|
|
|
|
require.True(t, more)
|
|
|
|
}
|
|
|
|
cancel()
|
|
|
|
require.EqualValues(t, codersdk.Workspace{}, <-wc)
|
|
|
|
}
|