2022-01-20 07:46:51 -06:00
package coderdtest
import (
2025-07-08 15:46:39 -06:00
"archive/tar"
2022-03-25 13:48:08 -06:00
"bytes"
2022-01-20 07:46:51 -06:00
"context"
2022-03-28 13:31:03 -06:00
"crypto"
2022-03-25 13:48:08 -06:00
"crypto/rand"
"crypto/rsa"
2022-03-28 13:31:03 -06:00
"crypto/sha256"
2022-10-17 08:43:30 -05:00
"crypto/tls"
2022-03-28 13:31:03 -06:00
"crypto/x509"
2022-04-19 08:48:13 -05:00
"crypto/x509/pkix"
2023-06-08 10:30:15 -05:00
"database/sql"
2022-03-25 13:48:08 -06:00
"encoding/base64"
"encoding/json"
2022-03-28 13:31:03 -06:00
"encoding/pem"
2022-09-06 12:07:00 -05:00
"errors"
2022-05-12 15:56:23 -05:00
"fmt"
2022-02-03 14:34:50 -06:00
"io"
2022-03-25 13:48:08 -06:00
"math/big"
2022-02-18 22:06:56 -06:00
"net"
2022-03-25 13:48:08 -06:00
"net/http"
2022-01-20 07:46:51 -06:00
"net/http/httptest"
"net/url"
2022-10-15 04:25:11 +10:00
"regexp"
2022-08-31 20:09:44 -05:00
"strconv"
2022-02-05 18:24:51 -06:00
"strings"
2022-10-17 08:43:30 -05:00
"sync"
2023-04-04 22:48:35 +10:00
"sync/atomic"
2022-01-20 07:46:51 -06:00
"testing"
2022-02-03 14:34:50 -06:00
"time"
2024-06-26 09:00:42 +01:00
"unicode"
2022-01-20 07:46:51 -06:00
2022-03-25 13:48:08 -06:00
"cloud.google.com/go/compute/metadata"
2022-04-19 08:48:13 -05:00
"github.com/fullsailor/pkcs7"
2025-01-08 15:15:30 +02:00
"github.com/go-chi/chi/v5"
2023-08-25 14:34:07 -05:00
"github.com/golang-jwt/jwt/v4"
2022-02-05 18:24:51 -06:00
"github.com/google/uuid"
"github.com/moby/moby/pkg/namesgenerator"
2023-02-14 08:27:06 -06:00
"github.com/prometheus/client_golang/prometheus"
2022-05-24 08:58:39 +01:00
"github.com/stretchr/testify/assert"
2022-01-20 07:46:51 -06:00
"github.com/stretchr/testify/require"
2022-06-29 14:17:32 -05:00
"golang.org/x/xerrors"
2022-02-21 14:36:29 -06:00
"google.golang.org/api/idtoken"
"google.golang.org/api/option"
2022-10-17 08:43:30 -05:00
"tailscale.com/derp"
2022-09-14 20:21:53 -05:00
"tailscale.com/net/stun/stuntest"
2022-08-31 20:09:44 -05:00
"tailscale.com/tailcfg"
2022-10-17 08:43:30 -05:00
"tailscale.com/types/key"
2022-09-14 20:21:53 -05:00
"tailscale.com/types/nettype"
2022-01-20 07:46:51 -06:00
2022-02-03 14:34:50 -06:00
"cdr.dev/slog"
2023-08-04 17:00:42 +01:00
"cdr.dev/slog/sloggers/sloghuman"
2022-01-20 07:46:51 -06:00
"cdr.dev/slog/sloggers/slogtest"
2025-07-08 15:46:39 -06:00
"github.com/coder/coder/v2/archive"
2025-06-23 12:35:15 -05:00
"github.com/coder/coder/v2/coderd/files"
2025-08-15 08:50:51 -07:00
"github.com/coder/coder/v2/coderd/provisionerdserver"
2025-07-22 13:39:26 +10:00
"github.com/coder/coder/v2/coderd/wsbuilder"
2025-03-24 16:02:33 +04:00
"github.com/coder/quartz"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd"
"github.com/coder/coder/v2/coderd/audit"
"github.com/coder/coder/v2/coderd/autobuild"
"github.com/coder/coder/v2/coderd/awsidentity"
2025-07-15 14:36:06 +10:00
"github.com/coder/coder/v2/coderd/connectionlog"
2024-10-25 17:14:35 +01:00
"github.com/coder/coder/v2/coderd/cryptokeys"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/database"
2024-06-11 08:55:28 -05:00
"github.com/coder/coder/v2/coderd/database/db2sdk"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/database/dbauthz"
2024-03-22 18:42:43 +02:00
"github.com/coder/coder/v2/coderd/database/dbrollup"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/database/dbtestutil"
"github.com/coder/coder/v2/coderd/database/pubsub"
2023-09-30 14:30:01 -05:00
"github.com/coder/coder/v2/coderd/externalauth"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/gitsshkey"
"github.com/coder/coder/v2/coderd/httpmw"
2025-05-20 15:22:44 +02:00
"github.com/coder/coder/v2/coderd/jobreaper"
2024-07-18 15:19:12 +02:00
"github.com/coder/coder/v2/coderd/notifications"
2024-11-12 12:40:46 +00:00
"github.com/coder/coder/v2/coderd/notifications/notificationstest"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/rbac"
2024-08-26 12:02:54 +01:00
"github.com/coder/coder/v2/coderd/rbac/policy"
2024-09-09 14:14:52 -05:00
"github.com/coder/coder/v2/coderd/runtimeconfig"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/schedule"
"github.com/coder/coder/v2/coderd/telemetry"
"github.com/coder/coder/v2/coderd/updatecheck"
"github.com/coder/coder/v2/coderd/util/ptr"
2025-03-27 10:03:53 +00:00
"github.com/coder/coder/v2/coderd/webpush"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/workspaceapps"
2024-01-17 10:41:42 -06:00
"github.com/coder/coder/v2/coderd/workspaceapps/appurl"
2024-06-10 15:35:23 -04:00
"github.com/coder/coder/v2/coderd/workspacestats"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/codersdk"
"github.com/coder/coder/v2/codersdk/agentsdk"
2025-05-12 10:31:38 -05:00
"github.com/coder/coder/v2/codersdk/drpcsdk"
2024-03-26 12:44:31 -05:00
"github.com/coder/coder/v2/codersdk/healthsdk"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/cryptorand"
"github.com/coder/coder/v2/provisioner/echo"
"github.com/coder/coder/v2/provisionerd"
provisionerdproto "github.com/coder/coder/v2/provisionerd/proto"
"github.com/coder/coder/v2/provisionersdk"
sdkproto "github.com/coder/coder/v2/provisionersdk/proto"
"github.com/coder/coder/v2/tailnet"
"github.com/coder/coder/v2/testutil"
2022-01-20 07:46:51 -06:00
)
2025-05-19 16:05:39 +01:00
const defaultTestDaemonName = "test-daemon"
2022-02-21 14:36:29 -06:00
type Options struct {
2022-12-16 04:43:00 +10:00
// AccessURL denotes a custom access URL. By default we use the httptest
// server's URL. Setting this may result in unexpected behavior (especially
// with running agents).
2024-08-20 17:16:49 +10:00
AccessURL * url . URL
AppHostname string
AWSCertificates awsidentity . Certificates
Authorizer rbac . Authorizer
AzureCertificates x509 . VerifyOptions
GithubOAuth2Config * coderd . GithubOAuth2Config
RealIPConfig * httpmw . RealIPConfig
OIDCConfig * coderd . OIDCConfig
GoogleTokenValidator * idtoken . Validator
SSHKeygenAlgorithm gitsshkey . Algorithm
AutobuildTicker <- chan time . Time
AutobuildStats chan <- autobuild . Stats
Auditor audit . Auditor
TLSCertificates [] tls . Certificate
ExternalAuthConfigs [] * externalauth . Config
TrialGenerator func ( ctx context . Context , body codersdk . LicensorTrialRequest ) error
RefreshEntitlements func ( ctx context . Context ) error
TemplateScheduleStore schedule . TemplateScheduleStore
Coordinator tailnet . Coordinator
CoordinatorResumeTokenProvider tailnet . ResumeTokenProvider
2025-07-15 14:36:06 +10:00
ConnectionLogger connectionlog . ConnectionLogger
2022-05-19 15:47:45 -07:00
2024-03-26 12:44:31 -05:00
HealthcheckFunc func ( ctx context . Context , apiKey string ) * healthsdk . HealthcheckReport
2023-04-03 01:28:42 -05:00
HealthcheckTimeout time . Duration
HealthcheckRefresh time . Duration
2023-01-05 12:05:20 -06:00
// All rate limits default to -1 (unlimited) in tests if not set.
APIRateLimit int
LoginRateLimit int
FilesRateLimit int
2024-10-04 11:53:25 +01:00
// OneTimePasscodeValidityPeriod specifies how long a one time passcode should be valid for.
OneTimePasscodeValidityPeriod time . Duration
2022-09-04 11:28:09 -05:00
// IncludeProvisionerDaemon when true means to start an in-memory provisionerD
2022-09-06 12:07:00 -05:00
IncludeProvisionerDaemon bool
2025-05-16 11:47:59 -05:00
ProvisionerDaemonVersion string
2024-06-04 13:59:54 +02:00
ProvisionerDaemonTags map [ string ] string
2022-09-06 12:07:00 -05:00
MetricsCacheRefreshInterval time . Duration
AgentStatsRefreshInterval time . Duration
2023-03-07 15:10:01 -06:00
DeploymentValues * codersdk . DeploymentValues
2022-10-17 08:43:30 -05:00
2022-12-01 19:43:28 +02:00
// Set update check options to enable update check.
UpdateCheckOptions * updatecheck . Options
2022-10-17 08:43:30 -05:00
// Overriding the database is heavily discouraged.
// It should only be used in cases where multiple Coder
// test instances are running against the same database.
Database database . Store
2023-06-14 10:34:54 -05:00
Pubsub pubsub . Pubsub
2022-12-19 18:43:46 +01:00
2025-01-08 15:15:30 +02:00
// APIMiddleware inserts middleware before api.RootHandler, this can be
// useful in certain tests where you want to intercept requests before
// passing them on to the API, e.g. for synchronization of execution.
APIMiddleware func ( http . Handler ) http . Handler
2023-03-16 13:03:37 -05:00
ConfigSSH codersdk . SSHConfigResponse
2022-12-19 18:43:46 +01:00
SwaggerEndpoint bool
2023-06-22 00:33:22 -04:00
// Logger should only be overridden if you expect errors
// as part of your test.
2023-08-04 17:00:42 +01:00
Logger * slog . Logger
2024-06-25 10:58:45 -04:00
StatsBatcher workspacestats . Batcher
2023-08-16 15:22:00 +03:00
2025-03-27 10:03:53 +00:00
WebpushDispatcher webpush . Dispatcher
2023-08-16 15:22:00 +03:00
WorkspaceAppsStatsCollectorOptions workspaceapps . StatsCollectorOptions
2023-12-15 13:38:47 -05:00
AllowWorkspaceRenames bool
2024-01-12 14:27:22 -06:00
NewTicker func ( duration time . Duration ) ( <- chan time . Time , func ())
2024-03-22 18:42:43 +02:00
DatabaseRolluper * dbrollup . Rolluper
2024-03-20 16:44:12 +00:00
WorkspaceUsageTrackerFlush chan int
WorkspaceUsageTrackerTick chan time . Time
2024-10-25 17:14:35 +01:00
NotificationsEnqueuer notifications . Enqueuer
APIKeyEncryptionCache cryptokeys . EncryptionKeycache
OIDCConvertKeyCache cryptokeys . SigningKeycache
Clock quartz . Clock
2025-03-24 16:02:33 +04:00
TelemetryReporter telemetry . Reporter
2025-08-28 15:00:26 +01:00
ProvisionerdServerMetrics * provisionerdserver . Metrics
2022-02-21 14:36:29 -06:00
}
2022-05-25 22:14:08 -05:00
// New constructs a codersdk client connected to an in-memory API instance.
2023-05-08 08:59:01 -05:00
func New ( t testing . TB , options * Options ) * codersdk . Client {
2022-06-27 13:50:52 -05:00
client , _ := newWithCloser ( t , options )
2022-05-25 22:14:08 -05:00
return client
2022-05-18 15:49:46 -05:00
}
2023-11-02 13:15:07 -04:00
// NewWithDatabase constructs a codersdk client connected to an in-memory API instance.
// The database is returned to provide direct data manipulation for tests.
func NewWithDatabase ( t testing . TB , options * Options ) ( * codersdk . Client , database . Store ) {
client , _ , api := NewWithAPI ( t , options )
return client , api . Database
}
2022-06-27 13:50:52 -05:00
// NewWithProvisionerCloser returns a client as well as a handle to close
// the provisioner. This is a temporary function while work is done to
// standardize how provisioners are registered with coderd. The option
// to include a provisioner is set to true for convenience.
2023-10-12 15:03:16 +03:00
func NewWithProvisionerCloser ( t testing . TB , options * Options ) ( * codersdk . Client , io . Closer ) {
2022-06-27 13:50:52 -05:00
if options == nil {
options = & Options {}
}
2022-09-04 11:28:09 -05:00
options . IncludeProvisionerDaemon = true
2022-06-27 13:50:52 -05:00
client , closer := newWithCloser ( t , options )
return client , closer
}
// newWithCloser constructs a codersdk client connected to an in-memory API instance.
// The returned closer closes a provisioner if it was provided
// The API is intentionally not returned here because coderd tests should not
// require a handle to the API. Do not expose the API or wrath shall descend
// upon thee. Even the io.Closer that is exposed here shouldn't be exposed
// and is a temporary measure while the API to register provisioners is ironed
// out.
2023-05-08 08:59:01 -05:00
func newWithCloser ( t testing . TB , options * Options ) ( * codersdk . Client , io . Closer ) {
2022-09-19 23:11:01 -05:00
client , closer , _ := NewWithAPI ( t , options )
2022-08-24 12:05:46 -07:00
return client , closer
}
2023-05-08 08:59:01 -05:00
func NewOptions ( t testing . TB , options * Options ) ( func ( http . Handler ), context . CancelFunc , * url . URL , * coderd . Options ) {
2023-06-13 20:18:31 +03:00
t . Helper ()
2022-02-21 14:36:29 -06:00
if options == nil {
options = & Options {}
}
2023-10-06 13:27:12 +04:00
if options . Logger == nil {
2024-08-05 12:07:06 -04:00
logger := slogtest . Make ( t , & slogtest . Options { IgnoreErrors : true }). Leveled ( slog . LevelDebug ). Named ( "coderd" )
2023-10-06 13:27:12 +04:00
options . Logger = & logger
}
2022-04-19 08:48:13 -05:00
if options . GoogleTokenValidator == nil {
2022-02-21 14:36:29 -06:00
ctx , cancelFunc := context . WithCancel ( context . Background ())
t . Cleanup ( cancelFunc )
var err error
2022-04-19 08:48:13 -05:00
options . GoogleTokenValidator , err = idtoken . NewValidator ( ctx , option . WithoutAuthentication ())
2022-02-21 14:36:29 -06:00
require . NoError ( t , err )
}
2022-05-13 17:14:24 +01:00
if options . AutobuildTicker == nil {
2022-05-11 23:03:02 +01:00
ticker := make ( chan time . Time )
2022-05-13 17:14:24 +01:00
options . AutobuildTicker = ticker
2022-05-11 23:03:02 +01:00
t . Cleanup ( func () { close ( ticker ) })
}
2022-05-30 20:23:36 +01:00
if options . AutobuildStats != nil {
t . Cleanup ( func () {
close ( options . AutobuildStats )
})
}
2023-03-21 09:10:22 -05:00
if options . Authorizer == nil {
2024-05-15 11:09:42 -05:00
defAuth := rbac . NewStrictCachingAuthorizer ( prometheus . NewRegistry ())
2023-05-08 08:59:01 -05:00
if _ , ok := t .( * testing . T ); ok {
options . Authorizer = & RecordingAuthorizer {
Wrapped : defAuth ,
}
} else {
// In benchmarks, the recording authorizer greatly skews results.
options . Authorizer = defAuth
2023-03-21 09:10:22 -05:00
}
}
2022-10-17 08:43:30 -05:00
if options . Database == nil {
options . Database , options . Pubsub = dbtestutil . NewDB ( t )
2023-01-25 21:35:53 +00:00
}
2024-08-20 17:16:49 +10:00
if options . CoordinatorResumeTokenProvider == nil {
options . CoordinatorResumeTokenProvider = tailnet . NewInsecureTestResumeTokenProvider ()
}
2023-03-21 09:10:22 -05:00
2024-07-18 15:19:12 +02:00
if options . NotificationsEnqueuer == nil {
2024-11-12 12:40:46 +00:00
options . NotificationsEnqueuer = & notificationstest . FakeEnqueuer {}
2024-07-18 15:19:12 +02:00
}
2023-11-28 17:56:49 -06:00
accessControlStore := & atomic . Pointer [ dbauthz . AccessControlStore ]{}
var acs dbauthz . AccessControlStore = dbauthz . AGPLTemplateAccessControlStore {}
accessControlStore . Store ( & acs )
2024-09-09 14:14:52 -05:00
runtimeManager := runtimeconfig . NewManager ()
2023-11-28 17:56:49 -06:00
options . Database = dbauthz . New ( options . Database , options . Authorizer , * options . Logger , accessControlStore )
2023-06-08 10:30:15 -05:00
// Some routes expect a deployment ID, so just make sure one exists.
// Check first incase the caller already set up this database.
// nolint:gocritic // Setting up unit test data inside test helper
depID , err := options . Database . GetDeploymentID ( dbauthz . AsSystemRestricted ( context . Background ()))
if xerrors . Is ( err , sql . ErrNoRows ) || depID == "" {
// nolint:gocritic // Setting up unit test data inside test helper
err := options . Database . InsertDeploymentID ( dbauthz . AsSystemRestricted ( context . Background ()), uuid . NewString ())
require . NoError ( t , err , "insert a deployment id" )
}
2025-03-27 10:03:53 +00:00
if options . WebpushDispatcher == nil {
// nolint:gocritic // Gets/sets VAPID keys.
2025-03-27 17:30:25 +00:00
pushNotifier , err := webpush . New ( dbauthz . AsNotifier ( context . Background ()), options . Logger , options . Database , "http://example.com" )
2025-03-27 10:03:53 +00:00
if err != nil {
panic ( xerrors . Errorf ( "failed to create web push notifier: %w" , err ))
}
options . WebpushDispatcher = pushNotifier
}
2023-03-07 15:10:01 -06:00
if options . DeploymentValues == nil {
options . DeploymentValues = DeploymentValues ( t )
2022-11-08 11:59:39 -05:00
}
2024-08-26 12:02:54 +01:00
// DisableOwnerWorkspaceExec modifies the 'global' RBAC roles. Fast-fail tests if we detect this.
if ! options . DeploymentValues . DisableOwnerWorkspaceExec . Value () {
ownerSubj := rbac . Subject {
Roles : rbac . RoleIdentifiers { rbac . RoleOwner ()},
Scope : rbac . ScopeAll ,
}
if err := options . Authorizer . Authorize ( context . Background (), ownerSubj , policy . ActionSSH , rbac . ResourceWorkspace ); err != nil {
if rbac . IsUnauthorizedError ( err ) {
t . Fatal ( "Side-effect of DisableOwnerWorkspaceExec detected in unrelated test. Please move the test that requires DisableOwnerWorkspaceExec to its own package so that it does not impact other tests!" )
}
require . NoError ( t , err )
}
2024-08-23 12:15:22 +01:00
}
2022-01-22 15:58:26 -06:00
2023-01-05 12:05:20 -06:00
// If no ratelimits are set, disable all rate limiting for tests.
if options . APIRateLimit == 0 {
options . APIRateLimit = - 1
}
if options . LoginRateLimit == 0 {
options . LoginRateLimit = - 1
}
if options . FilesRateLimit == 0 {
options . FilesRateLimit = - 1
}
2023-08-04 17:00:42 +01:00
if options . StatsBatcher == nil {
ctx , cancel := context . WithCancel ( context . Background ())
t . Cleanup ( cancel )
2024-06-10 15:35:23 -04:00
batcher , closeBatcher , err := workspacestats . NewBatcher ( ctx ,
workspacestats . BatcherWithStore ( options . Database ),
2023-08-04 17:00:42 +01:00
// Avoid cluttering up test output.
2024-06-10 15:35:23 -04:00
workspacestats . BatcherWithLogger ( slog . Make ( sloghuman . Sink ( io . Discard ))),
2023-08-04 17:00:42 +01:00
)
require . NoError ( t , err , "create stats batcher" )
options . StatsBatcher = batcher
t . Cleanup ( closeBatcher )
}
2024-07-24 13:38:21 -03:00
if options . NotificationsEnqueuer == nil {
2024-11-12 12:40:46 +00:00
options . NotificationsEnqueuer = & notificationstest . FakeEnqueuer {}
2024-07-24 13:38:21 -03:00
}
2023-01-05 12:05:20 -06:00
2024-10-04 11:53:25 +01:00
if options . OneTimePasscodeValidityPeriod == 0 {
options . OneTimePasscodeValidityPeriod = testutil . WaitLong
}
2023-04-04 22:48:35 +10:00
var templateScheduleStore atomic . Pointer [ schedule . TemplateScheduleStore ]
if options . TemplateScheduleStore == nil {
options . TemplateScheduleStore = schedule . NewAGPLTemplateScheduleStore ()
}
templateScheduleStore . Store ( & options . TemplateScheduleStore )
2023-10-05 13:41:07 -05:00
var auditor atomic . Pointer [ audit . Auditor ]
if options . Auditor == nil {
options . Auditor = audit . NewNop ()
}
auditor . Store ( & options . Auditor )
2025-07-15 14:36:06 +10:00
var connectionLogger atomic . Pointer [ connectionlog . ConnectionLogger ]
if options . ConnectionLogger == nil {
options . ConnectionLogger = connectionlog . NewNop ()
}
connectionLogger . Store ( & options . ConnectionLogger )
2025-07-22 13:39:26 +10:00
var buildUsageChecker atomic . Pointer [ wsbuilder . UsageChecker ]
var noopUsageChecker wsbuilder . UsageChecker = wsbuilder . NoopUsageChecker {}
buildUsageChecker . Store ( & noopUsageChecker )
2022-04-18 17:40:25 -05:00
ctx , cancelFunc := context . WithCancel ( context . Background ())
2025-05-20 10:09:53 -05:00
experiments := coderd . ReadExperiments ( * options . Logger , options . DeploymentValues . Experiments )
2023-06-22 00:33:22 -04:00
lifecycleExecutor := autobuild . NewExecutor (
2022-05-11 23:03:02 +01:00
ctx ,
2022-10-17 08:43:30 -05:00
options . Database ,
2023-09-19 10:25:57 +04:00
options . Pubsub ,
2025-06-23 12:35:15 -05:00
files . New ( prometheus . NewRegistry (), options . Authorizer ),
2024-10-30 10:20:47 -04:00
prometheus . NewRegistry (),
2023-04-04 22:48:35 +10:00
& templateScheduleStore ,
2023-10-05 13:41:07 -05:00
& auditor ,
2023-10-18 17:07:21 -05:00
accessControlStore ,
2025-07-22 13:39:26 +10:00
& buildUsageChecker ,
2023-10-06 13:27:12 +04:00
* options . Logger ,
2022-05-13 17:14:24 +01:00
options . AutobuildTicker ,
2024-07-18 15:19:12 +02:00
options . NotificationsEnqueuer ,
2025-05-20 10:09:53 -05:00
experiments ,
2022-05-30 20:23:36 +01:00
). WithStatsChannel ( options . AutobuildStats )
2025-08-15 08:50:51 -07:00
2022-05-11 23:03:02 +01:00
lifecycleExecutor . Run ()
2025-05-20 15:22:44 +02:00
jobReaperTicker := time . NewTicker ( options . DeploymentValues . JobReaperDetectorInterval . Value ())
defer jobReaperTicker . Stop ()
jobReaper := jobreaper . New ( ctx , options . Database , options . Pubsub , options . Logger . Named ( "reaper.detector" ), jobReaperTicker . C )
jobReaper . Start ()
t . Cleanup ( jobReaper . Close )
2023-06-25 23:17:00 +10:00
2025-03-24 16:02:33 +04:00
if options . TelemetryReporter == nil {
options . TelemetryReporter = telemetry . NewNoop ()
}
2024-03-20 16:44:12 +00:00
// Did last_used_at not update? Scratching your noggin? Here's why.
// Workspace usage tracking must be triggered manually in tests.
// The vast majority of existing tests do not depend on last_used_at
// and adding an extra time-based background goroutine to all existing
// tests may lead to future flakes and goleak complaints.
// Instead, pass in your own flush and ticker like so:
//
// tickCh = make(chan time.Time)
// flushCh = make(chan int, 1)
// client = coderdtest.New(t, &coderdtest.Options{
// WorkspaceUsageTrackerFlush: flushCh,
// WorkspaceUsageTrackerTick: tickCh
// })
//
// Now to trigger a tick, just write to `tickCh`.
// Reading from `flushCh` will ensure that workspaceusage.Tracker flushed.
// See TestPortForward or TestTracker_MultipleInstances for how this works in practice.
if options . WorkspaceUsageTrackerFlush == nil {
options . WorkspaceUsageTrackerFlush = make ( chan int , 1 ) // buffering just in case
}
if options . WorkspaceUsageTrackerTick == nil {
options . WorkspaceUsageTrackerTick = make ( chan time . Time , 1 ) // buffering just in case
}
// Close is called by API.Close()
2024-06-10 15:35:23 -04:00
wuTracker := workspacestats . NewTracker (
2024-03-20 16:44:12 +00:00
options . Database ,
2024-06-10 15:35:23 -04:00
workspacestats . TrackerWithLogger ( options . Logger . Named ( "workspace_usage_tracker" )),
workspacestats . TrackerWithTickFlush ( options . WorkspaceUsageTrackerTick , options . WorkspaceUsageTrackerFlush ),
2024-03-20 16:44:12 +00:00
)
2025-04-09 15:19:48 +04:00
// create the TempDir for the HTTP file cache BEFORE we start the server and set a t.Cleanup to close it. TempDir()
// registers a Cleanup function that deletes the directory, and Cleanup functions are called in reverse order. If
// we don't do this, then we could try to delete the directory before the HTTP server is done with all files in it,
// which on Windows will fail (can't delete files until all programs have closed handles to them).
cacheDir := t . TempDir ()
2022-10-17 08:43:30 -05:00
var mutex sync . RWMutex
var handler http . Handler
srv := httptest . NewUnstartedServer ( http . HandlerFunc ( func ( w http . ResponseWriter , r * http . Request ) {
mutex . RLock ()
2023-06-14 21:52:01 +10:00
handler := handler
mutex . RUnlock ()
2022-10-17 08:43:30 -05:00
if handler != nil {
handler . ServeHTTP ( w , r )
}
}))
2025-04-14 16:15:06 +04:00
t . Logf ( "coderdtest server listening on %s" , srv . Listener . Addr (). String ())
2022-02-18 22:06:56 -06:00
srv . Config . BaseContext = func ( _ net . Listener ) context . Context {
return ctx
}
2022-10-17 08:43:30 -05:00
if options . TLSCertificates != nil {
srv . TLS = & tls . Config {
Certificates : options . TLSCertificates ,
MinVersion : tls . VersionTLS12 ,
}
srv . StartTLS ()
} else {
srv . Start ()
}
2025-04-14 16:15:06 +04:00
t . Logf ( "coderdtest server started on %s" , srv . URL )
t . Cleanup ( func () {
t . Logf ( "closing coderdtest server on %s" , srv . Listener . Addr (). String ())
srv . Close ()
t . Logf ( "closed coderdtest server on %s" , srv . Listener . Addr (). String ())
})
2022-07-25 19:22:02 +03:00
2022-09-13 13:31:33 -04:00
tcpAddr , ok := srv . Listener . Addr ().( * net . TCPAddr )
require . True ( t , ok )
2022-01-20 10:00:13 -06:00
serverURL , err := url . Parse ( srv . URL )
2022-01-20 07:46:51 -06:00
require . NoError ( t , err )
2025-08-18 13:44:37 +10:00
serverURL . Host = fmt . Sprintf ( "127.0.0.1:%d" , tcpAddr . Port )
2022-04-05 19:18:26 -05:00
2022-08-31 20:09:44 -05:00
derpPort , err := strconv . Atoi ( serverURL . Port ())
require . NoError ( t , err )
2022-12-16 04:43:00 +10:00
accessURL := options . AccessURL
if accessURL == nil {
accessURL = serverURL
}
2023-08-01 08:50:43 -07:00
// If the STUNAddresses setting is empty or the default, start a STUN
// server. Otherwise, use the value as is.
var (
stunAddresses [] string
dvStunAddresses = options . DeploymentValues . DERP . Server . STUNAddresses . Value ()
)
2023-08-24 10:22:31 -07:00
if len ( dvStunAddresses ) == 0 || dvStunAddresses [ 0 ] == "stun.l.google.com:19302" {
2023-08-01 08:50:43 -07:00
stunAddr , stunCleanup := stuntest . ServeWithPacketListener ( t , nettype . Std {})
stunAddr . IP = net . ParseIP ( "127.0.0.1" )
t . Cleanup ( stunCleanup )
stunAddresses = [] string { stunAddr . String ()}
options . DeploymentValues . DERP . Server . STUNAddresses = stunAddresses
2023-08-27 14:46:44 -05:00
} else if dvStunAddresses [ 0 ] != tailnet . DisableSTUN {
2023-08-01 08:50:43 -07:00
stunAddresses = options . DeploymentValues . DERP . Server . STUNAddresses . Value ()
}
2022-09-14 20:21:53 -05:00
2023-10-06 13:27:12 +04:00
derpServer := derp . NewServer ( key . NewNode (), tailnet . Logger ( options . Logger . Named ( "derp" ). Leveled ( slog . LevelDebug )))
2022-10-17 08:43:30 -05:00
derpServer . SetMeshKey ( "test-key" )
2022-04-05 19:18:26 -05:00
// match default with cli default
if options . SSHKeygenAlgorithm == "" {
options . SSHKeygenAlgorithm = gitsshkey . AlgorithmEd25519
}
2022-10-15 04:25:11 +10:00
var appHostnameRegex * regexp . Regexp
if options . AppHostname != "" {
var err error
2024-01-17 10:41:42 -06:00
appHostnameRegex , err = appurl . CompileHostnamePattern ( options . AppHostname )
2022-10-15 04:25:11 +10:00
require . NoError ( t , err )
}
2023-06-22 08:02:05 +10:00
region := & tailcfg . DERPRegion {
EmbeddedRelay : true ,
RegionID : int ( options . DeploymentValues . DERP . Server . RegionID . Value ()),
RegionCode : options . DeploymentValues . DERP . Server . RegionCode . String (),
RegionName : options . DeploymentValues . DERP . Server . RegionName . String (),
Nodes : [] * tailcfg . DERPNode {{
Name : fmt . Sprintf ( "%db" , options . DeploymentValues . DERP . Server . RegionID ),
RegionID : int ( options . DeploymentValues . DERP . Server . RegionID . Value ()),
IPv4 : "127.0.0.1" ,
DERPPort : derpPort ,
// STUN port is added as a separate node by tailnet.NewDERPMap() if
// direct connections are enabled.
STUNPort : - 1 ,
InsecureForTests : true ,
ForceHTTP : options . TLSCertificates == nil ,
}},
}
if ! options . DeploymentValues . DERP . Server . Enable . Value () {
region = nil
}
2024-03-21 16:53:41 -05:00
derpMap , err := tailnet . NewDERPMap ( ctx , region , stunAddresses ,
options . DeploymentValues . DERP . Config . URL . Value (),
options . DeploymentValues . DERP . Config . Path . Value (),
options . DeploymentValues . DERP . Config . BlockDirect . Value (),
)
2023-06-22 08:02:05 +10:00
require . NoError ( t , err )
2022-10-17 08:43:30 -05:00
return func ( h http . Handler ) {
mutex . Lock ()
defer mutex . Unlock ()
handler = h
2022-12-16 04:43:00 +10:00
}, cancelFunc , serverURL , & coderd . Options {
2022-10-17 08:43:30 -05:00
AgentConnectionUpdateFrequency : 150 * time . Millisecond ,
// Force a long disconnection timeout to ensure
// agents are not marked as disconnected during slow tests.
AgentInactiveDisconnectTimeout : testutil . WaitShort ,
2022-12-16 04:43:00 +10:00
AccessURL : accessURL ,
2022-10-17 08:43:30 -05:00
AppHostname : options . AppHostname ,
AppHostnameRegex : appHostnameRegex ,
2023-06-22 00:33:22 -04:00
Logger : * options . Logger ,
2025-04-09 15:19:48 +04:00
CacheDir : cacheDir ,
2024-09-09 14:14:52 -05:00
RuntimeConfig : runtimeManager ,
2022-10-17 08:43:30 -05:00
Database : options . Database ,
Pubsub : options . Pubsub ,
2023-09-29 14:13:20 -05:00
ExternalAuthConfigs : options . ExternalAuthConfigs ,
2022-02-28 12:26:01 -06:00
2023-08-16 15:22:00 +03:00
Auditor : options . Auditor ,
2025-07-15 14:36:06 +10:00
ConnectionLogger : options . ConnectionLogger ,
2023-08-16 15:22:00 +03:00
AWSCertificates : options . AWSCertificates ,
AzureCertificates : options . AzureCertificates ,
GithubOAuth2Config : options . GithubOAuth2Config ,
RealIPConfig : options . RealIPConfig ,
OIDCConfig : options . OIDCConfig ,
GoogleTokenValidator : options . GoogleTokenValidator ,
SSHKeygenAlgorithm : options . SSHKeygenAlgorithm ,
DERPServer : derpServer ,
APIRateLimit : options . APIRateLimit ,
LoginRateLimit : options . LoginRateLimit ,
FilesRateLimit : options . FilesRateLimit ,
Authorizer : options . Authorizer ,
2025-03-24 16:02:33 +04:00
Telemetry : options . TelemetryReporter ,
2023-08-16 15:22:00 +03:00
TemplateScheduleStore : & templateScheduleStore ,
2023-10-18 17:07:21 -05:00
AccessControlStore : accessControlStore ,
2023-08-16 15:22:00 +03:00
TLSCertificates : options . TLSCertificates ,
TrialGenerator : options . TrialGenerator ,
2024-02-23 17:48:24 +01:00
RefreshEntitlements : options . RefreshEntitlements ,
2023-08-16 15:22:00 +03:00
TailnetCoordinator : options . Coordinator ,
2025-03-27 10:03:53 +00:00
WebPushDispatcher : options . WebpushDispatcher ,
2023-08-16 15:22:00 +03:00
BaseDERPMap : derpMap ,
DERPMapUpdateFrequency : 150 * time . Millisecond ,
2024-08-20 17:16:49 +10:00
CoordinatorResumeTokenProvider : options . CoordinatorResumeTokenProvider ,
2023-08-16 15:22:00 +03:00
MetricsCacheRefreshInterval : options . MetricsCacheRefreshInterval ,
AgentStatsRefreshInterval : options . AgentStatsRefreshInterval ,
DeploymentValues : options . DeploymentValues ,
2023-09-29 12:04:28 -05:00
DeploymentOptions : codersdk . DeploymentOptionsWithoutSecrets ( options . DeploymentValues . Options ()),
2023-08-16 15:22:00 +03:00
UpdateCheckOptions : options . UpdateCheckOptions ,
SwaggerEndpoint : options . SwaggerEndpoint ,
SSHConfig : options . ConfigSSH ,
HealthcheckFunc : options . HealthcheckFunc ,
HealthcheckTimeout : options . HealthcheckTimeout ,
HealthcheckRefresh : options . HealthcheckRefresh ,
StatsBatcher : options . StatsBatcher ,
WorkspaceAppsStatsCollectorOptions : options . WorkspaceAppsStatsCollectorOptions ,
2023-12-15 13:38:47 -05:00
AllowWorkspaceRenames : options . AllowWorkspaceRenames ,
2024-01-12 14:27:22 -06:00
NewTicker : options . NewTicker ,
2024-03-22 18:42:43 +02:00
DatabaseRolluper : options . DatabaseRolluper ,
2024-03-20 16:44:12 +00:00
WorkspaceUsageTracker : wuTracker ,
2024-07-18 15:19:12 +02:00
NotificationsEnqueuer : options . NotificationsEnqueuer ,
2024-10-04 11:53:25 +01:00
OneTimePasscodeValidityPeriod : options . OneTimePasscodeValidityPeriod ,
2024-10-25 17:14:35 +01:00
Clock : options . Clock ,
AppEncryptionKeyCache : options . APIKeyEncryptionCache ,
OIDCConvertKeyCache : options . OIDCConvertKeyCache ,
2025-08-28 15:00:26 +01:00
ProvisionerdServerMetrics : options . ProvisionerdServerMetrics ,
2022-10-17 08:43:30 -05:00
}
2022-09-19 23:11:01 -05:00
}
2022-06-27 13:50:52 -05:00
2022-09-19 23:11:01 -05:00
// NewWithAPI constructs an in-memory API instance and returns a client to talk to it.
// Most tests never need a reference to the API, but AuthorizationTest in this module uses it.
// Do not expose the API or wrath shall descend upon thee.
2023-05-08 08:59:01 -05:00
func NewWithAPI ( t testing . TB , options * Options ) ( * codersdk . Client , io . Closer , * coderd . API ) {
2022-09-19 23:11:01 -05:00
if options == nil {
options = & Options {}
}
2022-12-16 04:43:00 +10:00
setHandler , cancelFunc , serverURL , newOptions := NewOptions ( t , options )
2022-09-19 23:11:01 -05:00
// We set the handler after server creation for the access URL.
coderAPI := coderd . New ( newOptions )
2025-01-08 15:15:30 +02:00
rootHandler := coderAPI . RootHandler
if options . APIMiddleware != nil {
r := chi . NewRouter ()
r . Use ( options . APIMiddleware )
r . Mount ( "/" , rootHandler )
rootHandler = r
}
setHandler ( rootHandler )
2022-06-27 13:50:52 -05:00
var provisionerCloser io . Closer = nopcloser {}
2022-09-04 11:28:09 -05:00
if options . IncludeProvisionerDaemon {
2025-05-19 16:05:39 +01:00
provisionerCloser = NewTaggedProvisionerDaemon ( t , coderAPI , defaultTestDaemonName , options . ProvisionerDaemonTags , coderd . MemoryProvisionerWithVersionOverride ( options . ProvisionerDaemonVersion ))
2022-05-19 15:47:45 -07:00
}
2022-12-16 04:43:00 +10:00
client := codersdk . New ( serverURL )
2022-02-20 16:29:16 -06:00
t . Cleanup ( func () {
2022-09-19 23:11:01 -05:00
cancelFunc ()
2022-06-27 13:50:52 -05:00
_ = provisionerCloser . Close ()
2022-09-19 23:11:01 -05:00
_ = coderAPI . Close ()
2022-11-13 14:06:03 -06:00
client . HTTPClient . CloseIdleConnections ()
2022-02-20 16:29:16 -06:00
})
2022-11-13 14:06:03 -06:00
return client , provisionerCloser , coderAPI
2022-05-17 13:43:19 -05:00
}
2024-07-25 16:07:53 -05:00
// ProvisionerdCloser wraps a provisioner daemon as an io.Closer that can be called multiple times
type ProvisionerdCloser struct {
2023-09-19 10:25:57 +04:00
mu sync . Mutex
closed bool
d * provisionerd . Server
}
2024-07-25 16:07:53 -05:00
func NewProvisionerDaemonCloser ( d * provisionerd . Server ) * ProvisionerdCloser {
return & ProvisionerdCloser { d : d }
}
func ( c * ProvisionerdCloser ) Close () error {
2023-09-19 10:25:57 +04:00
c . mu . Lock ()
defer c . mu . Unlock ()
if c . closed {
return nil
}
c . closed = true
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
2024-03-15 14:16:36 +01:00
shutdownErr := c . d . Shutdown ( ctx , true )
2023-09-19 10:25:57 +04:00
closeErr := c . d . Close ()
if shutdownErr != nil {
return shutdownErr
}
return closeErr
}
2022-02-05 18:24:51 -06:00
// NewProvisionerDaemon launches a provisionerd instance configured to work
// well with coderd testing. It registers the "echo" provisioner for
// quick testing.
2023-05-08 08:59:01 -05:00
func NewProvisionerDaemon ( t testing . TB , coderAPI * coderd . API ) io . Closer {
2025-05-19 16:05:39 +01:00
return NewTaggedProvisionerDaemon ( t , coderAPI , defaultTestDaemonName , nil )
2024-06-04 13:59:54 +02:00
}
2025-05-16 11:47:59 -05:00
func NewTaggedProvisionerDaemon ( t testing . TB , coderAPI * coderd . API , name string , provisionerTags map [ string ] string , opts ... coderd . MemoryProvisionerDaemonOption ) io . Closer {
2023-06-13 20:18:31 +03:00
t . Helper ()
2023-09-13 13:13:08 -05:00
// t.Cleanup runs in last added, first called order. t.TempDir() will delete
// the directory on cleanup, so we want to make sure the echoServer is closed
// before we go ahead an attempt to delete it's work directory.
// seems t.TempDir() is not safe to call from a different goroutine
workDir := t . TempDir ()
2025-05-12 10:31:38 -05:00
echoClient , echoServer := drpcsdk . MemTransportPipe ()
2022-02-05 18:24:51 -06:00
ctx , cancelFunc := context . WithCancel ( context . Background ())
t . Cleanup ( func () {
_ = echoClient . Close ()
_ = echoServer . Close ()
cancelFunc ()
})
2023-09-13 13:13:08 -05:00
2022-02-05 18:24:51 -06:00
go func () {
2023-08-25 10:10:15 +04:00
err := echo . Serve ( ctx , & provisionersdk . ServeOptions {
Listener : echoServer ,
WorkDirectory : workDir ,
Logger : coderAPI . Logger . Named ( "echo" ). Leveled ( slog . LevelDebug ),
2022-02-05 18:24:51 -06:00
})
2022-05-24 08:58:39 +01:00
assert . NoError ( t , err )
2022-02-05 18:24:51 -06:00
}()
2024-12-20 09:49:19 +00:00
connectedCh := make ( chan struct {})
2024-01-10 15:29:57 +04:00
daemon := provisionerd . New ( func ( dialCtx context . Context ) ( provisionerdproto . DRPCProvisionerDaemonClient , error ) {
2025-05-16 11:47:59 -05:00
return coderAPI . CreateInMemoryTaggedProvisionerDaemon ( dialCtx , name , [] codersdk . ProvisionerType { codersdk . ProvisionerTypeEcho }, provisionerTags , opts ... )
2022-11-16 16:34:06 -06:00
}, & provisionerd . Options {
2023-06-22 00:33:22 -04:00
Logger : coderAPI . Logger . Named ( "provisionerd" ). Leveled ( slog . LevelDebug ),
2022-11-16 16:34:06 -06:00
UpdateInterval : 250 * time . Millisecond ,
2023-10-04 16:16:39 -05:00
ForceCancelInterval : 5 * time . Second ,
2023-09-08 13:53:48 +04:00
Connector : provisionerd . LocalProvisioners {
2022-11-22 12:19:32 -06:00
string ( database . ProvisionerTypeEcho ): sdkproto . NewDRPCProvisionerClient ( echoClient ),
2022-11-16 16:34:06 -06:00
},
2024-12-20 09:49:19 +00:00
InitConnectionCh : connectedCh ,
2022-11-16 16:34:06 -06:00
})
2024-12-20 09:49:19 +00:00
// Wait for the provisioner daemon to connect before continuing.
// Users of this function tend to assume that the provisioner is connected
// and ready to use when that may not strictly be the case.
<- connectedCh
2024-07-25 16:07:53 -05:00
closer := NewProvisionerDaemonCloser ( daemon )
2022-11-16 16:34:06 -06:00
t . Cleanup ( func () {
_ = closer . Close ()
})
return closer
}
2022-05-06 09:20:08 -05:00
var FirstUserParams = codersdk . CreateFirstUserRequest {
2022-11-16 17:09:49 -06:00
Email : "testuser@coder.com" ,
Username : "testuser" ,
2023-02-08 14:10:08 -06:00
Password : "SomeSecurePassword!" ,
2024-06-26 09:00:42 +01:00
Name : "Test User" ,
2022-05-06 09:20:08 -05:00
}
2024-10-29 18:32:20 +05:30
var TrialUserParams = codersdk . CreateFirstUserTrialInfo {
FirstName : "John" ,
LastName : "Doe" ,
PhoneNumber : "9999999999" ,
JobTitle : "Engineer" ,
CompanyName : "Acme Inc" ,
Country : "United States" ,
Developers : "10-50" ,
}
2022-03-07 11:40:54 -06:00
// CreateFirstUser creates a user with preset credentials and authenticates
2022-02-05 18:24:51 -06:00
// with the passed in codersdk client.
2023-05-08 08:59:01 -05:00
func CreateFirstUser ( t testing . TB , client * codersdk . Client ) codersdk . CreateFirstUserResponse {
2022-05-06 09:20:08 -05:00
resp , err := client . CreateFirstUser ( context . Background (), FirstUserParams )
2022-02-05 18:24:51 -06:00
require . NoError ( t , err )
2022-03-22 13:17:50 -06:00
login , err := client . LoginWithPassword ( context . Background (), codersdk . LoginWithPasswordRequest {
2022-05-06 09:20:08 -05:00
Email : FirstUserParams . Email ,
Password : FirstUserParams . Password ,
2022-02-05 18:24:51 -06:00
})
require . NoError ( t , err )
2022-11-09 15:31:24 +02:00
client . SetSessionToken ( login . SessionToken )
2022-03-07 11:40:54 -06:00
return resp
2022-02-05 18:24:51 -06:00
}
2022-03-07 11:40:54 -06:00
// CreateAnotherUser creates and authenticates a new user.
2024-06-05 11:25:02 -05:00
// Roles can include org scoped roles with 'roleName:<organization_id>'
2024-06-11 08:55:28 -05:00
func CreateAnotherUser ( t testing . TB , client * codersdk . Client , organizationID uuid . UUID , roles ... rbac . RoleIdentifier ) ( * codersdk . Client , codersdk . User ) {
2024-08-23 16:23:51 -05:00
return createAnotherUserRetry ( t , client , [] uuid . UUID { organizationID }, 5 , roles )
2022-06-29 14:17:32 -05:00
}
2024-08-23 16:23:51 -05:00
func CreateAnotherUserMutators ( t testing . TB , client * codersdk . Client , organizationID uuid . UUID , roles [] rbac . RoleIdentifier , mutators ... func ( r * codersdk . CreateUserRequestWithOrgs )) ( * codersdk . Client , codersdk . User ) {
return createAnotherUserRetry ( t , client , [] uuid . UUID { organizationID }, 5 , roles , mutators ... )
2023-06-14 12:48:43 -05:00
}
2023-11-20 13:16:18 -06:00
// AuthzUserSubject does not include the user's groups.
2023-12-07 13:55:29 -05:00
func AuthzUserSubject ( user codersdk . User , orgID uuid . UUID ) rbac . Subject {
2024-06-11 08:55:28 -05:00
roles := make ( rbac . RoleIdentifiers , 0 , len ( user . Roles ))
2023-12-07 13:55:29 -05:00
// Member role is always implied
roles = append ( roles , rbac . RoleMember ())
2023-11-20 13:16:18 -06:00
for _ , r := range user . Roles {
2024-06-11 08:55:28 -05:00
orgID , _ := uuid . Parse ( r . OrganizationID ) // defaults to nil
roles = append ( roles , rbac . RoleIdentifier {
Name : r . Name ,
OrganizationID : orgID ,
})
2023-11-20 13:16:18 -06:00
}
2023-12-07 13:55:29 -05:00
// We assume only 1 org exists
2024-06-05 11:25:02 -05:00
roles = append ( roles , rbac . ScopedRoleOrgMember ( orgID ))
2023-11-20 13:16:18 -06:00
return rbac . Subject {
ID : user . ID . String (),
Roles : roles ,
Groups : [] string {},
Scope : rbac . ScopeAll ,
}
}
2024-08-23 16:23:51 -05:00
func createAnotherUserRetry ( t testing . TB , client * codersdk . Client , organizationIDs [] uuid . UUID , retries int , roles [] rbac . RoleIdentifier , mutators ... func ( r * codersdk . CreateUserRequestWithOrgs )) ( * codersdk . Client , codersdk . User ) {
req := codersdk . CreateUserRequestWithOrgs {
Email : namesgenerator . GetRandomName ( 10 ) + "@coder.com" ,
Username : RandomUsername ( t ),
Name : RandomName ( t ),
Password : "SomeSecurePassword!" ,
OrganizationIDs : organizationIDs ,
2024-10-31 17:55:42 -05:00
// Always create users as active in tests to ignore an extra audit log
// when logging in.
UserStatus : ptr . Ref ( codersdk . UserStatusActive ),
2022-03-07 11:40:54 -06:00
}
2023-06-14 12:48:43 -05:00
for _ , m := range mutators {
m ( & req )
}
2022-06-29 14:17:32 -05:00
2024-08-23 16:23:51 -05:00
user , err := client . CreateUserWithOrgs ( context . Background (), req )
2022-06-29 14:17:32 -05:00
var apiError * codersdk . Error
// If the user already exists by username or email conflict, try again up to "retries" times.
if err != nil && retries >= 0 && xerrors . As ( err , & apiError ) {
if apiError . StatusCode () == http . StatusConflict {
retries --
2024-08-23 16:23:51 -05:00
return createAnotherUserRetry ( t , client , organizationIDs , retries , roles )
2022-06-29 14:17:32 -05:00
}
}
2022-03-07 11:40:54 -06:00
require . NoError ( t , err )
2023-06-14 12:48:43 -05:00
var sessionToken string
2024-08-23 16:23:51 -05:00
if req . UserLoginType == codersdk . LoginTypeNone {
2023-06-14 12:48:43 -05:00
// Cannot log in with a disabled login user. So make it an api key from
// the client making this user.
token , err := client . CreateToken ( context . Background (), user . ID . String (), codersdk . CreateTokenRequest {
Lifetime : time . Hour * 24 ,
Scope : codersdk . APIKeyScopeAll ,
TokenName : "no-password-user-token" ,
})
require . NoError ( t , err )
sessionToken = token . Key
2023-08-10 20:04:35 -05:00
} else {
login , err := client . LoginWithPassword ( context . Background (), codersdk . LoginWithPasswordRequest {
Email : req . Email ,
Password : req . Password ,
})
require . NoError ( t , err )
sessionToken = login . SessionToken
2023-06-14 12:48:43 -05:00
}
2022-03-07 11:40:54 -06:00
2023-08-02 16:31:25 +02:00
if user . Status == codersdk . UserStatusDormant {
// Use admin client so that user's LastSeenAt is not updated.
// In general we need to refresh the user status, which should
// transition from "dormant" to "active".
user , err = client . User ( context . Background (), user . Username )
require . NoError ( t , err )
}
2025-09-22 21:02:56 +04:00
other := codersdk . New ( client . URL , codersdk . WithSessionToken ( sessionToken ))
2023-02-25 16:01:01 -06:00
t . Cleanup ( func () {
other . HTTPClient . CloseIdleConnections ()
})
2022-05-12 15:56:23 -05:00
if len ( roles ) > 0 {
// Find the roles for the org vs the site wide roles
2024-06-11 08:55:28 -05:00
orgRoles := make ( map [ uuid . UUID ][] rbac . RoleIdentifier )
var siteRoles [] rbac . RoleIdentifier
2022-05-12 15:56:23 -05:00
for _ , roleName := range roles {
2024-06-11 08:55:28 -05:00
ok := roleName . IsOrgRole ()
2022-05-12 15:56:23 -05:00
if ok {
2024-06-11 08:55:28 -05:00
orgRoles [ roleName . OrganizationID ] = append ( orgRoles [ roleName . OrganizationID ], roleName )
2022-05-12 15:56:23 -05:00
} else {
siteRoles = append ( siteRoles , roleName )
}
}
// Update the roles
for _ , r := range user . Roles {
2024-06-11 08:55:28 -05:00
orgID , _ := uuid . Parse ( r . OrganizationID )
siteRoles = append ( siteRoles , rbac . RoleIdentifier {
Name : r . Name ,
OrganizationID : orgID ,
})
2022-05-12 15:56:23 -05:00
}
2022-05-17 13:43:19 -05:00
2024-06-11 08:55:28 -05:00
onlyName := func ( role rbac . RoleIdentifier ) string {
return role . Name
}
user , err = client . UpdateUserRoles ( context . Background (), user . ID . String (), codersdk . UpdateRoles { Roles : db2sdk . List ( siteRoles , onlyName )})
2022-05-12 15:56:23 -05:00
require . NoError ( t , err , "update site roles" )
2024-07-10 07:38:48 -10:00
// isMember keeps track of which orgs the user was added to as a member
2024-08-23 16:23:51 -05:00
isMember := make ( map [ uuid . UUID ] bool )
for _ , orgID := range organizationIDs {
isMember [ orgID ] = true
2024-07-10 07:38:48 -10:00
}
2022-05-12 15:56:23 -05:00
// Update org roles
for orgID , roles := range orgRoles {
2024-07-10 07:38:48 -10:00
// The user must be an organization of any orgRoles, so insert
// the organization member, then assign the roles.
if ! isMember [ orgID ] {
_ , err = client . PostOrganizationMember ( context . Background (), orgID , user . ID . String ())
require . NoError ( t , err , "add user to organization as member" )
}
2024-06-11 08:55:28 -05:00
_ , err = client . UpdateOrganizationMemberRoles ( context . Background (), orgID , user . ID . String (),
codersdk . UpdateRoles { Roles : db2sdk . List ( roles , onlyName )})
2022-05-12 15:56:23 -05:00
require . NoError ( t , err , "update org membership roles" )
2024-07-10 07:38:48 -10:00
isMember [ orgID ] = true
2022-05-12 15:56:23 -05:00
}
}
2024-07-10 07:38:48 -10:00
user , err = client . User ( context . Background (), user . Username )
require . NoError ( t , err , "update final user" )
2022-08-09 13:16:53 -05:00
return other , user
2022-03-07 11:40:54 -06:00
}
2025-07-08 15:46:39 -06:00
func CreateTemplateVersionMimeType ( t testing . TB , client * codersdk . Client , mimeType string , organizationID uuid . UUID , res * echo . Responses , mutators ... func ( * codersdk . CreateTemplateVersionRequest )) codersdk . TemplateVersion {
2022-10-10 15:37:06 -05:00
t . Helper ()
2023-11-16 16:52:04 +01:00
data , err := echo . TarWithOptions ( context . Background (), client . Logger (), res )
2022-02-08 12:00:44 -06:00
require . NoError ( t , err )
2025-07-08 15:46:39 -06:00
switch mimeType {
case codersdk . ContentTypeTar :
// do nothing
case codersdk . ContentTypeZip :
data , err = archive . CreateZipFromTar ( tar . NewReader ( bytes . NewBuffer ( data )), int64 ( len ( data )))
require . NoError ( t , err , "creating zip" )
default :
t . Fatal ( "unexpected mime type" , mimeType )
}
file , err := client . Upload ( context . Background (), mimeType , bytes . NewReader ( data ))
2022-02-08 12:00:44 -06:00
require . NoError ( t , err )
2023-02-15 18:24:15 +01:00
req := codersdk . CreateTemplateVersionRequest {
2022-10-13 18:02:52 -05:00
FileID : file . ID ,
2022-05-19 13:04:44 -05:00
StorageMethod : codersdk . ProvisionerStorageMethodFile ,
Provisioner : codersdk . ProvisionerTypeEcho ,
2023-02-15 18:24:15 +01:00
}
for _ , mut := range mutators {
mut ( & req )
}
templateVersion , err := client . CreateTemplateVersion ( context . Background (), organizationID , req )
2022-02-08 12:00:44 -06:00
require . NoError ( t , err )
2022-04-06 12:42:40 -05:00
return templateVersion
2022-02-08 12:00:44 -06:00
}
2025-07-08 15:46:39 -06:00
// CreateTemplateVersion creates a template import provisioner job
// with the responses provided. It uses the "echo" provisioner for compatibility
// with testing.
func CreateTemplateVersion ( t testing . TB , client * codersdk . Client , organizationID uuid . UUID , res * echo . Responses , mutators ... func ( * codersdk . CreateTemplateVersionRequest )) codersdk . TemplateVersion {
return CreateTemplateVersionMimeType ( t , client , codersdk . ContentTypeTar , organizationID , res , mutators ... )
}
2022-05-18 09:33:33 -07:00
// CreateWorkspaceBuild creates a workspace build for the given workspace and transition.
func CreateWorkspaceBuild (
t * testing . T ,
client * codersdk . Client ,
workspace codersdk . Workspace ,
2022-07-22 20:02:49 +03:00
transition database . WorkspaceTransition ,
2023-07-14 15:07:48 -08:00
mutators ... func ( * codersdk . CreateWorkspaceBuildRequest ),
2022-07-22 20:02:49 +03:00
) codersdk . WorkspaceBuild {
2023-11-30 19:33:04 -06:00
t . Helper ()
2022-05-18 09:33:33 -07:00
req := codersdk . CreateWorkspaceBuildRequest {
2022-05-19 13:04:44 -05:00
Transition : codersdk . WorkspaceTransition ( transition ),
2022-05-18 09:33:33 -07:00
}
2023-07-14 15:07:48 -08:00
for _ , mut := range mutators {
mut ( & req )
}
2022-05-18 09:33:33 -07:00
build , err := client . CreateWorkspaceBuild ( context . Background (), workspace . ID , req )
require . NoError ( t , err )
return build
}
2022-04-06 12:42:40 -05:00
// CreateTemplate creates a template with the "echo" provisioner for
2022-02-05 18:24:51 -06:00
// compatibility with testing. The name assigned is randomly generated.
2023-10-12 15:03:16 +03:00
func CreateTemplate ( t testing . TB , client * codersdk . Client , organization uuid . UUID , version uuid . UUID , mutators ... func ( * codersdk . CreateTemplateRequest )) codersdk . Template {
2022-06-07 13:37:45 +01:00
req := codersdk . CreateTemplateRequest {
2023-10-19 17:16:15 -05:00
Name : RandomUsername ( t ),
2023-04-20 10:59:57 -07:00
VersionID : version ,
2022-06-07 13:37:45 +01:00
}
for _ , mut := range mutators {
mut ( & req )
}
template , err := client . CreateTemplate ( context . Background (), organization , req )
2022-02-05 18:24:51 -06:00
require . NoError ( t , err )
2022-04-06 12:42:40 -05:00
return template
2022-02-05 18:24:51 -06:00
}
2023-11-08 14:54:48 +00:00
// CreateGroup creates a group with the given name and members.
func CreateGroup ( t testing . TB , client * codersdk . Client , organizationID uuid . UUID , name string , members ... codersdk . User ) codersdk . Group {
t . Helper ()
group , err := client . CreateGroup ( context . Background (), organizationID , codersdk . CreateGroupRequest {
Name : name ,
})
require . NoError ( t , err , "failed to create group" )
memberIDs := make ([] string , 0 )
for _ , member := range members {
memberIDs = append ( memberIDs , member . ID . String ())
}
group , err = client . PatchGroup ( context . Background (), group . ID , codersdk . PatchGroupRequest {
AddUsers : memberIDs ,
})
require . NoError ( t , err , "failed to add members to group" )
return group
}
2022-05-11 23:03:02 +01:00
// UpdateTemplateVersion creates a new template version with the "echo" provisioner
// and associates it with the given templateID.
2023-10-12 15:03:16 +03:00
func UpdateTemplateVersion ( t testing . TB , client * codersdk . Client , organizationID uuid . UUID , res * echo . Responses , templateID uuid . UUID ) codersdk . TemplateVersion {
2023-10-10 10:20:31 -05:00
ctx := context . Background ()
2022-05-11 23:03:02 +01:00
data , err := echo . Tar ( res )
require . NoError ( t , err )
2023-10-10 10:20:31 -05:00
file , err := client . Upload ( ctx , codersdk . ContentTypeTar , bytes . NewReader ( data ))
2022-05-11 23:03:02 +01:00
require . NoError ( t , err )
2023-10-10 10:20:31 -05:00
templateVersion , err := client . CreateTemplateVersion ( ctx , organizationID , codersdk . CreateTemplateVersionRequest {
2022-05-11 23:03:02 +01:00
TemplateID : templateID ,
2022-10-13 18:02:52 -05:00
FileID : file . ID ,
2022-05-19 13:04:44 -05:00
StorageMethod : codersdk . ProvisionerStorageMethodFile ,
Provisioner : codersdk . ProvisionerTypeEcho ,
2022-05-11 23:03:02 +01:00
})
require . NoError ( t , err )
return templateVersion
}
2023-10-12 15:03:16 +03:00
func UpdateActiveTemplateVersion ( t testing . TB , client * codersdk . Client , templateID , versionID uuid . UUID ) {
2023-10-10 10:20:31 -05:00
err := client . UpdateActiveTemplateVersion ( context . Background (), templateID , codersdk . UpdateActiveTemplateVersion {
ID : versionID ,
})
require . NoError ( t , err )
}
2023-11-08 14:54:48 +00:00
// UpdateTemplateMeta updates the template meta for the given template.
func UpdateTemplateMeta ( t testing . TB , client * codersdk . Client , templateID uuid . UUID , meta codersdk . UpdateTemplateMeta ) codersdk . Template {
t . Helper ()
updated , err := client . UpdateTemplateMeta ( context . Background (), templateID , meta )
require . NoError ( t , err )
return updated
}
2023-10-05 10:49:25 -06:00
// AwaitTemplateVersionJobRunning waits for the build to be picked up by a provisioner.
2023-10-12 15:03:16 +03:00
func AwaitTemplateVersionJobRunning ( t testing . TB , client * codersdk . Client , version uuid . UUID ) codersdk . TemplateVersion {
2023-10-05 10:49:25 -06:00
t . Helper ()
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
t . Logf ( "waiting for template version %s build job to start" , version )
var templateVersion codersdk . TemplateVersion
require . Eventually ( t , func () bool {
var err error
templateVersion , err = client . TemplateVersion ( ctx , version )
if err != nil {
return false
}
t . Logf ( "template version job status: %s" , templateVersion . Job . Status )
switch templateVersion . Job . Status {
case codersdk . ProvisionerJobPending :
return false
case codersdk . ProvisionerJobRunning :
return true
default :
t . FailNow ()
return false
}
}, testutil . WaitShort , testutil . IntervalFast , "make sure you set `IncludeProvisionerDaemon`!" )
t . Logf ( "template version %s job has started" , version )
return templateVersion
}
// AwaitTemplateVersionJobCompleted waits for the build to be completed. This may result
// from cancelation, an error, or from completing successfully.
2023-10-12 15:03:16 +03:00
func AwaitTemplateVersionJobCompleted ( t testing . TB , client * codersdk . Client , version uuid . UUID ) codersdk . TemplateVersion {
2022-07-22 20:02:49 +03:00
t . Helper ()
2023-09-22 13:13:50 -05:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
2022-12-13 21:28:07 +02:00
defer cancel ()
2023-10-05 10:49:25 -06:00
t . Logf ( "waiting for template version %s build job to complete" , version )
2022-04-06 12:42:40 -05:00
var templateVersion codersdk . TemplateVersion
2022-09-04 11:28:09 -05:00
require . Eventually ( t , func () bool {
2022-02-05 18:24:51 -06:00
var err error
2022-12-13 21:28:07 +02:00
templateVersion , err = client . TemplateVersion ( ctx , version )
2023-10-05 10:49:25 -06:00
t . Logf ( "template version job status: %s" , templateVersion . Job . Status )
2022-07-22 20:02:49 +03:00
return assert . NoError ( t , err ) && templateVersion . Job . CompletedAt != nil
2023-10-05 10:49:25 -06:00
}, testutil . WaitLong , testutil . IntervalMedium , "make sure you set `IncludeProvisionerDaemon`!" )
t . Logf ( "template version %s job has completed" , version )
2022-04-06 12:42:40 -05:00
return templateVersion
2022-02-12 13:34:04 -06:00
}
2023-10-03 11:02:56 -06:00
// AwaitWorkspaceBuildJobCompleted waits for a workspace provision job to reach completed status.
2023-10-12 15:03:16 +03:00
func AwaitWorkspaceBuildJobCompleted ( t testing . TB , client * codersdk . Client , build uuid . UUID ) codersdk . WorkspaceBuild {
2022-07-22 20:02:49 +03:00
t . Helper ()
2022-12-13 21:28:07 +02:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
2022-07-22 20:02:49 +03:00
t . Logf ( "waiting for workspace build job %s" , build )
2022-03-22 13:17:50 -06:00
var workspaceBuild codersdk . WorkspaceBuild
2022-09-04 11:28:09 -05:00
require . Eventually ( t , func () bool {
2022-11-14 11:57:33 -06:00
var err error
2022-12-13 21:28:07 +02:00
workspaceBuild , err = client . WorkspaceBuild ( ctx , build )
2025-09-09 08:38:32 +02:00
if err != nil {
t . Logf ( "failed to get workspace build %s: %v" , build , err )
return false
}
if workspaceBuild . Job . CompletedAt == nil {
t . Logf ( "workspace build job %s still running (status: %s)" , build , workspaceBuild . Job . Status )
return false
}
return true
2023-09-22 13:13:50 -05:00
}, testutil . WaitMedium , testutil . IntervalMedium )
2025-09-09 08:38:32 +02:00
t . Logf ( "got workspace build job %s (status: %s)" , build , workspaceBuild . Job . Status )
2022-03-07 11:40:54 -06:00
return workspaceBuild
}
2023-03-31 00:24:51 +11:00
// AwaitWorkspaceAgents waits for all resources with agents to be connected. If
// specific agents are provided, it will wait for those agents to be connected
// but will not fail if other agents are not connected.
2024-01-30 07:44:47 +04:00
//
// Deprecated: Use NewWorkspaceAgentWaiter
2023-09-26 12:05:19 +01:00
func AwaitWorkspaceAgents ( t testing . TB , client * codersdk . Client , workspaceID uuid . UUID , agentNames ... string ) [] codersdk . WorkspaceResource {
2024-01-30 07:44:47 +04:00
return NewWorkspaceAgentWaiter ( t , client , workspaceID ). AgentNames ( agentNames ). Wait ()
}
2022-07-22 20:02:49 +03:00
2024-01-30 07:44:47 +04:00
// WorkspaceAgentWaiter waits for all resources with agents to be connected. If
// specific agents are provided using AgentNames(), it will wait for those agents
// to be connected but will not fail if other agents are not connected.
type WorkspaceAgentWaiter struct {
t testing . TB
client * codersdk . Client
workspaceID uuid . UUID
agentNames [] string
resourcesMatcher func ([] codersdk . WorkspaceResource ) bool
2025-10-17 13:45:11 +01:00
ctx context . Context
2024-01-30 07:44:47 +04:00
}
// NewWorkspaceAgentWaiter returns an object that waits for agents to connect when
// you call Wait() on it.
func NewWorkspaceAgentWaiter ( t testing . TB , client * codersdk . Client , workspaceID uuid . UUID ) WorkspaceAgentWaiter {
return WorkspaceAgentWaiter {
t : t ,
client : client ,
workspaceID : workspaceID ,
}
}
// AgentNames instructs the waiter to wait for the given, named agents to be connected and will
// return even if other agents are not connected.
func ( w WorkspaceAgentWaiter ) AgentNames ( names [] string ) WorkspaceAgentWaiter {
//nolint: revive // returns modified struct
w . agentNames = names
return w
}
// MatchResources instructs the waiter to wait until the workspace has resources that cause the
// provided matcher function to return true.
func ( w WorkspaceAgentWaiter ) MatchResources ( m func ([] codersdk . WorkspaceResource ) bool ) WorkspaceAgentWaiter {
//nolint: revive // returns modified struct
w . resourcesMatcher = m
return w
}
2025-10-17 13:45:11 +01:00
// WithContext instructs the waiter to use the provided context for all operations.
// If not specified, the waiter will create its own context with testutil.WaitLong timeout.
func ( w WorkspaceAgentWaiter ) WithContext ( ctx context . Context ) WorkspaceAgentWaiter {
//nolint: revive // returns modified struct
w . ctx = ctx
return w
}
2025-05-14 14:15:36 +02:00
// WaitForAgentFn represents a boolean assertion to be made against each agent
// that a given WorkspaceAgentWaited knows about. Each WaitForAgentFn should apply
// the check to a single agent, but it should be named for plural, because `func (w WorkspaceAgentWaiter) WaitFor`
// applies the check to all agents that it is aware of. This ensures that the public API of the waiter
// reads correctly. For example:
//
// waiter := coderdtest.NewWorkspaceAgentWaiter(t, client, r.Workspace.ID)
// waiter.WaitFor(coderdtest.AgentsReady)
type WaitForAgentFn func ( agent codersdk . WorkspaceAgent ) bool
// AgentsReady checks that the latest lifecycle state of an agent is "Ready".
func AgentsReady ( agent codersdk . WorkspaceAgent ) bool {
return agent . LifecycleState == codersdk . WorkspaceAgentLifecycleReady
}
// AgentsNotReady checks that the latest lifecycle state of an agent is anything except "Ready".
func AgentsNotReady ( agent codersdk . WorkspaceAgent ) bool {
return ! AgentsReady ( agent )
}
2025-10-17 13:45:11 +01:00
// WaitFor waits for the given criteria and fails the test if they are not met before the
// waiter's context is canceled.
2025-05-14 14:15:36 +02:00
func ( w WorkspaceAgentWaiter ) WaitFor ( criteria ... WaitForAgentFn ) {
w . t . Helper ()
agentNamesMap := make ( map [ string ] struct {}, len ( w . agentNames ))
for _ , name := range w . agentNames {
agentNamesMap [ name ] = struct {}{}
}
2025-10-17 13:45:11 +01:00
ctx := w . ctx
if w . ctx == nil {
ctx = testutil . Context ( w . t , testutil . WaitLong )
}
2025-05-14 14:15:36 +02:00
w . t . Logf ( "waiting for workspace agents (workspace %s)" , w . workspaceID )
2025-10-17 13:45:11 +01:00
testutil . Eventually ( ctx , w . t , func ( ctx context . Context ) bool {
2025-05-14 14:15:36 +02:00
var err error
workspace , err := w . client . Workspace ( ctx , w . workspaceID )
if err != nil {
return false
}
if workspace . LatestBuild . Job . CompletedAt == nil {
return false
}
if workspace . LatestBuild . Job . CompletedAt . IsZero () {
return false
}
for _ , resource := range workspace . LatestBuild . Resources {
for _ , agent := range resource . Agents {
if len ( w . agentNames ) > 0 {
if _ , ok := agentNamesMap [ agent . Name ]; ! ok {
continue
}
}
for _ , criterium := range criteria {
if ! criterium ( agent ) {
return false
}
}
}
}
return true
2025-10-17 13:45:11 +01:00
}, testutil . IntervalMedium )
2025-05-14 14:15:36 +02:00
}
2025-10-17 13:45:11 +01:00
// Wait waits for the agent(s) to connect and fails the test if they do not connect before the
// waiter's context is canceled.
2024-01-30 07:44:47 +04:00
func ( w WorkspaceAgentWaiter ) Wait () [] codersdk . WorkspaceResource {
w . t . Helper ()
agentNamesMap := make ( map [ string ] struct {}, len ( w . agentNames ))
for _ , name := range w . agentNames {
2023-03-31 00:24:51 +11:00
agentNamesMap [ name ] = struct {}{}
}
2025-10-17 13:45:11 +01:00
ctx := w . ctx
if w . ctx == nil {
ctx = testutil . Context ( w . t , testutil . WaitLong )
}
2022-12-13 21:28:07 +02:00
2024-01-30 07:44:47 +04:00
w . t . Logf ( "waiting for workspace agents (workspace %s)" , w . workspaceID )
2022-03-22 13:17:50 -06:00
var resources [] codersdk . WorkspaceResource
2025-10-17 13:45:11 +01:00
testutil . Eventually ( ctx , w . t , func ( ctx context . Context ) bool {
2022-03-07 11:40:54 -06:00
var err error
2024-01-30 07:44:47 +04:00
workspace , err := w . client . Workspace ( ctx , w . workspaceID )
2024-06-03 14:46:56 -05:00
if err != nil {
2022-07-22 20:02:49 +03:00
return false
}
2023-10-09 22:12:28 +04:00
if workspace . LatestBuild . Job . CompletedAt == nil {
return false
}
2022-10-03 17:01:13 -04:00
if workspace . LatestBuild . Job . CompletedAt . IsZero () {
return false
}
for _ , resource := range workspace . LatestBuild . Resources {
2022-04-11 16:06:15 -05:00
for _ , agent := range resource . Agents {
2024-01-30 07:44:47 +04:00
if len ( w . agentNames ) > 0 {
2023-03-31 00:24:51 +11:00
if _ , ok := agentNamesMap [ agent . Name ]; ! ok {
continue
}
}
2022-04-11 18:54:30 -05:00
if agent . Status != codersdk . WorkspaceAgentConnected {
2024-01-30 07:44:47 +04:00
w . t . Logf ( "agent %s not connected yet" , agent . Name )
2022-04-11 16:06:15 -05:00
return false
}
2022-03-07 11:40:54 -06:00
}
}
2022-10-03 17:01:13 -04:00
resources = workspace . LatestBuild . Resources
2024-01-30 07:44:47 +04:00
if w . resourcesMatcher == nil {
return true
}
return w . resourcesMatcher ( resources )
2025-10-17 13:45:11 +01:00
}, testutil . IntervalMedium )
2024-01-30 07:44:47 +04:00
w . t . Logf ( "got workspace agents (workspace %s)" , w . workspaceID )
2022-03-07 11:40:54 -06:00
return resources
2022-02-05 18:24:51 -06:00
}
2022-04-06 12:42:40 -05:00
// CreateWorkspace creates a workspace for the user and template provided.
2022-02-05 18:24:51 -06:00
// A random name is generated for it.
2022-05-23 23:31:41 +01:00
// To customize the defaults, pass a mutator func.
2024-07-30 10:44:02 -06:00
func CreateWorkspace ( t testing . TB , client * codersdk . Client , templateID uuid . UUID , mutators ... func ( * codersdk . CreateWorkspaceRequest )) codersdk . Workspace {
2022-05-23 23:31:41 +01:00
t . Helper ()
req := codersdk . CreateWorkspaceRequest {
TemplateID : templateID ,
2023-10-19 17:16:15 -05:00
Name : RandomUsername ( t ),
2022-06-07 13:37:45 +01:00
AutostartSchedule : ptr . Ref ( "CRON_TZ=US/Central 30 9 * * 1-5" ),
2022-06-02 11:23:34 +01:00
TTLMillis : ptr . Ref (( 8 * time . Hour ). Milliseconds ()),
2023-10-06 13:27:12 +04:00
AutomaticUpdates : codersdk . AutomaticUpdatesNever ,
2022-05-23 23:31:41 +01:00
}
for _ , mutator := range mutators {
mutator ( & req )
}
2024-07-30 10:44:02 -06:00
workspace , err := client . CreateUserWorkspace ( context . Background (), codersdk . Me , req )
2022-02-05 18:24:51 -06:00
require . NoError ( t , err )
return workspace
}
2022-06-07 13:37:45 +01:00
// TransitionWorkspace is a convenience method for transitioning a workspace from one state to another.
2025-06-23 09:12:37 +01:00
func MustTransitionWorkspace ( t testing . TB , client * codersdk . Client , workspaceID uuid . UUID , from , to codersdk . WorkspaceTransition , muts ... func ( req * codersdk . CreateWorkspaceBuildRequest )) codersdk . Workspace {
2022-06-07 13:37:45 +01:00
t . Helper ()
ctx := context . Background ()
workspace , err := client . Workspace ( ctx , workspaceID )
require . NoError ( t , err , "unexpected error fetching workspace" )
2025-06-23 09:12:37 +01:00
require . Equal ( t , workspace . LatestBuild . Transition , from , "expected workspace state: %s got: %s" , from , workspace . LatestBuild . Transition )
2022-06-07 13:37:45 +01:00
2023-10-18 17:07:21 -05:00
req := codersdk . CreateWorkspaceBuildRequest {
2023-11-02 14:41:34 -05:00
TemplateVersionID : workspace . LatestBuild . TemplateVersionID ,
2025-06-23 09:12:37 +01:00
Transition : to ,
2023-10-18 17:07:21 -05:00
}
for _ , mut := range muts {
mut ( & req )
}
build , err := client . CreateWorkspaceBuild ( ctx , workspace . ID , req )
2022-06-07 13:37:45 +01:00
require . NoError ( t , err , "unexpected error transitioning workspace to %s" , to )
2023-10-03 11:02:56 -06:00
_ = AwaitWorkspaceBuildJobCompleted ( t , client , build . ID )
2022-06-07 13:37:45 +01:00
updated := MustWorkspace ( t , client , workspace . ID )
2025-06-23 09:12:37 +01:00
require . Equal ( t , to , updated . LatestBuild . Transition , "expected workspace to be in state %s but got %s" , to , updated . LatestBuild . Transition )
2022-06-07 13:37:45 +01:00
return updated
}
// MustWorkspace is a convenience method for fetching a workspace that should exist.
2023-10-12 15:03:16 +03:00
func MustWorkspace ( t testing . TB , client * codersdk . Client , workspaceID uuid . UUID ) codersdk . Workspace {
2022-06-07 13:37:45 +01:00
t . Helper ()
ctx := context . Background ()
ws , err := client . Workspace ( ctx , workspaceID )
if err != nil && strings . Contains ( err . Error (), "status code 410" ) {
ws , err = client . DeletedWorkspace ( ctx , workspaceID )
}
require . NoError ( t , err , "no workspace found with id %s" , workspaceID )
return ws
}
2023-09-30 14:30:01 -05:00
// RequestExternalAuthCallback makes a request with the proper OAuth2 state cookie
// to the external auth callback endpoint.
2024-09-10 15:58:50 +01:00
func RequestExternalAuthCallback ( t testing . TB , providerID string , client * codersdk . Client , opts ... func ( * http . Request )) * http . Response {
2025-03-26 01:56:39 -05:00
client . HTTPClient . CheckRedirect = func ( _ * http . Request , _ [] * http . Request ) error {
2023-02-27 10:18:19 -06:00
return http . ErrUseLastResponse
}
state := "somestate"
2023-10-03 09:04:39 -05:00
oauthURL , err := client . URL . Parse ( fmt . Sprintf ( "/external-auth/%s/callback?code=asd&state=%s" , providerID , state ))
2023-02-27 10:18:19 -06:00
require . NoError ( t , err )
req , err := http . NewRequestWithContext ( context . Background (), "GET" , oauthURL . String (), nil )
require . NoError ( t , err )
req . AddCookie ( & http . Cookie {
Name : codersdk . OAuth2StateCookie ,
Value : state ,
})
req . AddCookie ( & http . Cookie {
Name : codersdk . SessionTokenCookie ,
Value : client . SessionToken (),
})
2024-09-10 15:58:50 +01:00
for _ , opt := range opts {
opt ( req )
}
2023-02-27 10:18:19 -06:00
res , err := client . HTTPClient . Do ( req )
require . NoError ( t , err )
t . Cleanup ( func () {
_ = res . Body . Close ()
})
return res
}
2022-03-25 13:48:08 -06:00
// NewGoogleInstanceIdentity returns a metadata client and ID token validator for faking
// instance authentication for Google Cloud.
// nolint:revive
2023-10-12 15:03:16 +03:00
func NewGoogleInstanceIdentity ( t testing . TB , instanceID string , expired bool ) ( * idtoken . Validator , * metadata . Client ) {
2022-03-25 13:48:08 -06:00
keyID , err := cryptorand . String ( 12 )
require . NoError ( t , err )
claims := jwt . MapClaims {
"google" : map [ string ] interface {}{
"compute_engine" : map [ string ] string {
"instance_id" : instanceID ,
},
},
}
if ! expired {
claims [ "exp" ] = time . Now (). AddDate ( 1 , 0 , 0 ). Unix ()
}
token := jwt . NewWithClaims ( jwt . SigningMethodRS256 , claims )
token . Header [ "kid" ] = keyID
privateKey , err := rsa . GenerateKey ( rand . Reader , 2048 )
require . NoError ( t , err )
signedKey , err := token . SignedString ( privateKey )
require . NoError ( t , err )
// Taken from: https://github.com/googleapis/google-api-go-client/blob/4bb729045d611fa77bdbeb971f6a1204ba23161d/idtoken/validate.go#L57-L75
type jwk struct {
Kid string `json:"kid"`
N string `json:"n"`
E string `json:"e"`
}
type certResponse struct {
Keys [] jwk `json:"keys"`
}
validator , err := idtoken . NewValidator ( context . Background (), option . WithHTTPClient ( & http . Client {
Transport : roundTripper ( func ( r * http . Request ) ( * http . Response , error ) {
data , err := json . Marshal ( certResponse {
Keys : [] jwk {{
Kid : keyID ,
N : base64 . RawURLEncoding . EncodeToString ( privateKey . N . Bytes ()),
E : base64 . RawURLEncoding . EncodeToString ( new ( big . Int ). SetInt64 ( int64 ( privateKey . E )). Bytes ()),
}},
})
require . NoError ( t , err )
return & http . Response {
StatusCode : http . StatusOK ,
2022-03-29 14:59:32 -05:00
Body : io . NopCloser ( bytes . NewReader ( data )),
2022-03-25 13:48:08 -06:00
Header : make ( http . Header ),
}, nil
}),
}))
require . NoError ( t , err )
return validator , metadata . NewClient ( & http . Client {
Transport : roundTripper ( func ( r * http . Request ) ( * http . Response , error ) {
return & http . Response {
StatusCode : http . StatusOK ,
2022-03-29 14:59:32 -05:00
Body : io . NopCloser ( bytes . NewReader ([] byte ( signedKey ))),
2022-03-25 13:48:08 -06:00
Header : make ( http . Header ),
}, nil
}),
})
}
2022-03-28 13:31:03 -06:00
// NewAWSInstanceIdentity returns a metadata client and ID token validator for faking
// instance authentication for AWS.
2023-10-12 15:03:16 +03:00
func NewAWSInstanceIdentity ( t testing . TB , instanceID string ) ( awsidentity . Certificates , * http . Client ) {
2022-03-28 13:31:03 -06:00
privateKey , err := rsa . GenerateKey ( rand . Reader , 2048 )
require . NoError ( t , err )
document := [] byte ( `{"instanceId":"` + instanceID + `"}` )
hashedDocument := sha256 . Sum256 ( document )
signatureRaw , err := rsa . SignPKCS1v15 ( rand . Reader , privateKey , crypto . SHA256 , hashedDocument [:])
require . NoError ( t , err )
signature := make ([] byte , base64 . StdEncoding . EncodedLen ( len ( signatureRaw )))
base64 . StdEncoding . Encode ( signature , signatureRaw )
certificate , err := x509 . CreateCertificate ( rand . Reader , & x509 . Certificate {
SerialNumber : big . NewInt ( 2022 ),
}, & x509 . Certificate {}, & privateKey . PublicKey , privateKey )
require . NoError ( t , err )
certificatePEM := bytes . Buffer {}
err = pem . Encode ( & certificatePEM , & pem . Block {
Type : "CERTIFICATE" ,
Bytes : certificate ,
})
require . NoError ( t , err )
return awsidentity . Certificates {
awsidentity . Other : certificatePEM . String (),
}, & http . Client {
Transport : roundTripper ( func ( r * http . Request ) ( * http . Response , error ) {
// Only handle metadata server requests.
if r . URL . Host != "169.254.169.254" {
return http . DefaultTransport . RoundTrip ( r )
}
switch r . URL . Path {
case "/latest/api/token" :
return & http . Response {
StatusCode : http . StatusOK ,
2022-03-29 14:59:32 -05:00
Body : io . NopCloser ( bytes . NewReader ([] byte ( "faketoken" ))),
2022-03-28 13:31:03 -06:00
Header : make ( http . Header ),
}, nil
case "/latest/dynamic/instance-identity/signature" :
return & http . Response {
StatusCode : http . StatusOK ,
2022-03-29 14:59:32 -05:00
Body : io . NopCloser ( bytes . NewReader ( signature )),
2022-03-28 13:31:03 -06:00
Header : make ( http . Header ),
}, nil
case "/latest/dynamic/instance-identity/document" :
return & http . Response {
StatusCode : http . StatusOK ,
2022-03-29 14:59:32 -05:00
Body : io . NopCloser ( bytes . NewReader ( document )),
2022-03-28 13:31:03 -06:00
Header : make ( http . Header ),
}, nil
default :
panic ( "unhandled route: " + r . URL . Path )
}
}),
}
}
2022-04-19 08:48:13 -05:00
// NewAzureInstanceIdentity returns a metadata client and ID token validator for faking
// instance authentication for Azure.
2023-10-12 15:03:16 +03:00
func NewAzureInstanceIdentity ( t testing . TB , instanceID string ) ( x509 . VerifyOptions , * http . Client ) {
2022-04-19 08:48:13 -05:00
privateKey , err := rsa . GenerateKey ( rand . Reader , 2048 )
require . NoError ( t , err )
rawCertificate , err := x509 . CreateCertificate ( rand . Reader , & x509 . Certificate {
SerialNumber : big . NewInt ( 2022 ),
NotAfter : time . Now (). AddDate ( 1 , 0 , 0 ),
Subject : pkix . Name {
CommonName : "metadata.azure.com" ,
},
}, & x509 . Certificate {}, & privateKey . PublicKey , privateKey )
require . NoError ( t , err )
certificate , err := x509 . ParseCertificate ( rawCertificate )
require . NoError ( t , err )
signed , err := pkcs7 . NewSignedData ([] byte ( `{"vmId":"` + instanceID + `"}` ))
require . NoError ( t , err )
err = signed . AddSigner ( certificate , privateKey , pkcs7 . SignerInfoConfig {})
require . NoError ( t , err )
signatureRaw , err := signed . Finish ()
require . NoError ( t , err )
signature := make ([] byte , base64 . StdEncoding . EncodedLen ( len ( signatureRaw )))
base64 . StdEncoding . Encode ( signature , signatureRaw )
2023-01-29 15:47:24 -06:00
payload , err := json . Marshal ( agentsdk . AzureInstanceIdentityToken {
2022-04-19 08:48:13 -05:00
Signature : string ( signature ),
Encoding : "pkcs7" ,
})
require . NoError ( t , err )
certPool := x509 . NewCertPool ()
certPool . AddCert ( certificate )
return x509 . VerifyOptions {
Intermediates : certPool ,
Roots : certPool ,
}, & http . Client {
Transport : roundTripper ( func ( r * http . Request ) ( * http . Response , error ) {
// Only handle metadata server requests.
if r . URL . Host != "169.254.169.254" {
return http . DefaultTransport . RoundTrip ( r )
}
switch r . URL . Path {
case "/metadata/attested/document" :
return & http . Response {
StatusCode : http . StatusOK ,
Body : io . NopCloser ( bytes . NewReader ( payload )),
Header : make ( http . Header ),
}, nil
default :
panic ( "unhandled route: " + r . URL . Path )
}
}),
}
}
2023-10-19 17:16:15 -05:00
func RandomUsername ( t testing . TB ) string {
2023-04-06 11:53:02 -05:00
suffix , err := cryptorand . String ( 3 )
require . NoError ( t , err )
2023-04-20 21:40:36 +03:00
suffix = "-" + suffix
n := strings . ReplaceAll ( namesgenerator . GetRandomName ( 10 ), "_" , "-" ) + suffix
if len ( n ) > 32 {
n = n [: 32 - len ( suffix )] + suffix
}
return n
2022-01-20 07:46:51 -06:00
}
2022-03-25 13:48:08 -06:00
2024-06-26 09:00:42 +01:00
func RandomName ( t testing . TB ) string {
var sb strings . Builder
var err error
ss := strings . Split ( namesgenerator . GetRandomName ( 10 ), "_" )
for si , s := range ss {
for ri , r := range s {
if ri == 0 {
_ , err = sb . WriteRune ( unicode . ToTitle ( r ))
require . NoError ( t , err )
} else {
_ , err = sb . WriteRune ( r )
require . NoError ( t , err )
}
}
if si < len ( ss ) - 1 {
_ , err = sb . WriteRune ( ' ' )
require . NoError ( t , err )
}
}
return sb . String ()
}
2022-03-25 13:48:08 -06:00
// Used to easily create an HTTP transport!
type roundTripper func ( req * http . Request ) ( * http . Response , error )
func ( r roundTripper ) RoundTrip ( req * http . Request ) ( * http . Response , error ) {
return r ( req )
}
2022-06-27 13:50:52 -05:00
type nopcloser struct {}
func ( nopcloser ) Close () error { return nil }
2022-09-06 12:07:00 -05:00
// SDKError coerces err into an SDK error.
2023-10-12 15:03:16 +03:00
func SDKError ( t testing . TB , err error ) * codersdk . Error {
2022-09-06 12:07:00 -05:00
var cerr * codersdk . Error
2025-09-11 13:17:09 -08:00
require . True ( t , errors . As ( err , & cerr ), "should be SDK error, got %w" , err )
2022-09-06 12:07:00 -05:00
return cerr
}
2022-10-17 22:07:11 -05:00
2024-08-23 12:15:22 +01:00
func DeploymentValues ( t testing . TB , mut ... func ( * codersdk . DeploymentValues )) * codersdk . DeploymentValues {
cfg := & codersdk . DeploymentValues {}
2023-03-07 15:10:01 -06:00
opts := cfg . Options ()
2023-04-07 17:58:21 -05:00
err := opts . SetDefaults ()
2022-11-08 11:59:39 -05:00
require . NoError ( t , err )
2024-08-23 12:15:22 +01:00
for _ , fn := range mut {
fn ( cfg )
}
return cfg
2022-11-08 11:59:39 -05:00
}
2025-08-15 08:50:51 -07:00
// GetProvisionerForTags returns the first valid provisioner for a workspace + template tags.
func GetProvisionerForTags ( tx database . Store , curTime time . Time , orgID uuid . UUID , tags map [ string ] string ) ( database . ProvisionerDaemon , error ) {
if tags == nil {
tags = map [ string ] string {}
}
queryParams := database . GetProvisionerDaemonsByOrganizationParams {
OrganizationID : orgID ,
WantTags : tags ,
}
// nolint: gocritic // The user (in this case, the user/context for autostart builds) may not have the full
// permissions to read provisioner daemons, but we need to check if there's any for the job prior to the
// execution of the job via autostart to fix: https://github.com/coder/coder/issues/17941
provisionerDaemons , err := tx . GetProvisionerDaemonsByOrganization ( dbauthz . AsSystemReadProvisionerDaemons ( context . Background ()), queryParams )
if err != nil {
return database . ProvisionerDaemon {}, xerrors . Errorf ( "get provisioner daemons: %w" , err )
}
// Check if any provisioners are active (not stale)
for _ , pd := range provisionerDaemons {
if pd . LastSeenAt . Valid {
age := curTime . Sub ( pd . LastSeenAt . Time )
if age <= provisionerdserver . StaleInterval {
return pd , nil
}
}
}
return database . ProvisionerDaemon {}, xerrors . New ( "no available provisioners found" )
}
func ctxWithProvisionerPermissions ( ctx context . Context ) context . Context {
// Use system restricted context which has permissions to update provisioner daemons
//nolint: gocritic // We need system context to modify this.
return dbauthz . AsSystemRestricted ( ctx )
}
// UpdateProvisionerLastSeenAt updates the provisioner daemon's LastSeenAt timestamp
// to the specified time to prevent it from appearing stale during autobuild operations
func UpdateProvisionerLastSeenAt ( t * testing . T , db database . Store , id uuid . UUID , tickTime time . Time ) {
t . Helper ()
ctx := ctxWithProvisionerPermissions ( context . Background ())
t . Logf ( "Updating provisioner %s LastSeenAt to %v" , id , tickTime )
err := db . UpdateProvisionerDaemonLastSeenAt ( ctx , database . UpdateProvisionerDaemonLastSeenAtParams {
ID : id ,
LastSeenAt : sql . NullTime { Time : tickTime , Valid : true },
})
require . NoError ( t , err )
t . Logf ( "Successfully updated provisioner LastSeenAt" )
}
func MustWaitForAnyProvisioner ( t * testing . T , db database . Store ) {
t . Helper ()
ctx := ctxWithProvisionerPermissions ( testutil . Context ( t , testutil . WaitShort ))
2025-08-28 12:07:50 -07:00
// testutil.Eventually(t, func)
testutil . Eventually ( ctx , t , func ( ctx context . Context ) ( done bool ) {
2025-08-15 08:50:51 -07:00
daemons , err := db . GetProvisionerDaemons ( ctx )
return err == nil && len ( daemons ) > 0
2025-08-28 12:07:50 -07:00
}, testutil . IntervalFast , "no provisioner daemons found" )
}
// MustWaitForProvisionersUnavailable waits for provisioners to become unavailable for a specific workspace
func MustWaitForProvisionersUnavailable ( t * testing . T , db database . Store , workspace codersdk . Workspace , tags map [ string ] string , checkTime time . Time ) {
t . Helper ()
ctx := ctxWithProvisionerPermissions ( testutil . Context ( t , testutil . WaitMedium ))
testutil . Eventually ( ctx , t , func ( ctx context . Context ) ( done bool ) {
// Use the same logic as hasValidProvisioner but expect false
provisionerDaemons , err := db . GetProvisionerDaemonsByOrganization ( ctx , database . GetProvisionerDaemonsByOrganizationParams {
OrganizationID : workspace . OrganizationID ,
WantTags : tags ,
})
if err != nil {
return false
}
// Check if NO provisioners are active (all are stale or gone)
for _ , pd := range provisionerDaemons {
if pd . LastSeenAt . Valid {
age := checkTime . Sub ( pd . LastSeenAt . Time )
if age <= provisionerdserver . StaleInterval {
return false // Found an active provisioner, keep waiting
}
}
}
return true // No active provisioners found
}, testutil . IntervalFast , "there are still provisioners available for workspace, expected none" )
2025-08-15 08:50:51 -07:00
}
// MustWaitForProvisionersAvailable waits for provisioners to be available for a specific workspace.
2025-08-28 12:07:50 -07:00
func MustWaitForProvisionersAvailable ( t * testing . T , db database . Store , workspace codersdk . Workspace , ts time . Time ) uuid . UUID {
2025-08-15 08:50:51 -07:00
t . Helper ()
2025-08-28 12:07:50 -07:00
ctx := ctxWithProvisionerPermissions ( testutil . Context ( t , testutil . WaitLong ))
2025-08-15 08:50:51 -07:00
id := uuid . UUID {}
// Get the workspace from the database
2025-08-28 12:07:50 -07:00
testutil . Eventually ( ctx , t , func ( ctx context . Context ) ( done bool ) {
2025-08-15 08:50:51 -07:00
ws , err := db . GetWorkspaceByID ( ctx , workspace . ID )
if err != nil {
return false
}
// Get the latest build
latestBuild , err := db . GetWorkspaceBuildByID ( ctx , workspace . LatestBuild . ID )
if err != nil {
return false
}
// Get the template version job
templateVersionJob , err := db . GetProvisionerJobByID ( ctx , latestBuild . JobID )
if err != nil {
return false
}
// Check if provisioners are available using the same logic as hasAvailableProvisioners
provisionerDaemons , err := db . GetProvisionerDaemonsByOrganization ( ctx , database . GetProvisionerDaemonsByOrganizationParams {
OrganizationID : ws . OrganizationID ,
WantTags : templateVersionJob . Tags ,
})
if err != nil {
return false
}
// Check if any provisioners are active (not stale)
for _ , pd := range provisionerDaemons {
if pd . LastSeenAt . Valid {
2025-08-28 12:07:50 -07:00
age := ts . Sub ( pd . LastSeenAt . Time )
2025-08-15 08:50:51 -07:00
if age <= provisionerdserver . StaleInterval {
id = pd . ID
return true // Found an active provisioner
}
}
}
return false // No active provisioners found
2025-08-28 12:07:50 -07:00
}, testutil . IntervalFast , "no active provisioners available for workspace, expected at least one (non-stale)" )
2025-08-15 08:50:51 -07:00
return id
}