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"
2026-08-11 12:02:34 +02:00
"net/netip"
2022-01-20 07:46:51 -06:00
"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"
2022-01-20 07:46:51 -06:00
2022-03-25 13:48:08 -06:00
"cloud.google.com/go/compute/metadata"
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"
2026-07-21 11:19:23 +02:00
"github.com/nats-io/nats-server/v2/server"
2023-02-14 08:27:06 -06:00
"github.com/prometheus/client_golang/prometheus"
2026-05-13 16:14:07 +02:00
"github.com/smallstep/pkcs7"
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"
2026-01-09 15:40:26 -07:00
"golang.org/x/text/cases"
"golang.org/x/text/language"
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
2026-01-08 10:29:41 +04:00
"cdr.dev/slog/v3"
"cdr.dev/slog/v3/sloggers/sloghuman"
"cdr.dev/slog/v3/sloggers/slogtest"
2025-07-08 15:46:39 -06:00
"github.com/coder/coder/v2/archive"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd"
2026-01-22 22:47:49 -08:00
"github.com/coder/coder/v2/coderd/agentapi/metadatabatcher"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/audit"
"github.com/coder/coder/v2/coderd/autobuild"
"github.com/coder/coder/v2/coderd/awsidentity"
2026-05-13 16:14:07 +02:00
"github.com/coder/coder/v2/coderd/azureidentity"
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"
"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"
2026-01-08 15:24:11 +04:00
"github.com/coder/coder/v2/coderd/files"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/gitsshkey"
2026-01-15 16:37:05 +00:00
"github.com/coder/coder/v2/coderd/healthcheck"
2026-11-13 17:20:31 +01:00
"github.com/coder/coder/v2/coderd/healthcheck/health"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/httpmw"
2025-05-20 15:22:44 +02:00
"github.com/coder/coder/v2/coderd/jobreaper"
2026-10-05 16:52:36 -07:00
natspubsub "github.com/coder/coder/v2/coderd/nats"
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"
2026-01-08 15:24:11 +04:00
"github.com/coder/coder/v2/coderd/provisionerdserver"
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"
2026-01-12 18:19:19 -08:00
"github.com/coder/coder/v2/coderd/rbac/rolestore"
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"
2026-01-27 19:01:17 -06:00
"github.com/coder/coder/v2/coderd/usage"
2026-01-09 15:40:26 -07:00
"github.com/coder/coder/v2/coderd/util/namesgenerator"
2026-02-03 17:52:07 +00:00
"github.com/coder/coder/v2/coderd/util/slice"
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"
2026-01-08 15:24:11 +04:00
"github.com/coder/coder/v2/coderd/wsbuilder"
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"
2026-01-08 15:24:11 +04:00
"github.com/coder/quartz"
2022-01-20 07:46:51 -06:00
)
2026-02-27 00:07:14 +11:00
const DefaultDERPMeshKey = "test-key"
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).
2026-08-11 12:02:34 +02:00
AccessURL * url . URL
AppHostname string
AWSCertificates awsidentity . Certificates
Authorizer rbac . Authorizer
AzureCertificates azureidentity . Options
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
2026-08-30 13:09:17 +02:00
// MCPAllowedPrivateCIDRs exempts IP ranges from the MCP
// SSRF guard for MCP server and OAuth2 traffic. Defaults to loopback so
// tests can serve mock MCP and authorization servers via httptest.
MCPAllowedPrivateCIDRs [] netip . Prefix
RefreshEntitlements func ( ctx context . Context ) error
TemplateScheduleStore schedule . TemplateScheduleStore
Coordinator tailnet . Coordinator
CoordinatorResumeTokenProvider tailnet . ResumeTokenProvider
ConnectionLogger connectionlog . ConnectionLogger
2022-05-19 15:47:45 -07:00
2026-01-15 16:37:05 +00:00
HealthcheckFunc func ( ctx context . Context , apiKey string , progress * healthcheck . Progress ) * 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
2026-09-05 11:39:10 +02:00
IncludeProvisionerDaemon bool
2026-06-12 14:47:34 +02:00
// ChatWorkerDisabled skips starting the chat daemon's background
// worker. Used in tests.
ChatWorkerDisabled bool
ProvisionerDaemonVersion string
ProvisionerDaemonTags map [ string ] string
MetricsCacheRefreshInterval time . Duration
AgentStatsRefreshInterval time . Duration
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.
2026-06-03 15:37:19 -05:00
Database database . Store
Pubsub pubsub . Pubsub
2026-07-21 11:19:23 +02:00
ReplicaSyncPubsub 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.
2026-01-22 22:47:49 -08:00
Logger * slog . Logger
StatsBatcher workspacestats . Batcher
MetadataBatcherOptions [] metadatabatcher . Option
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
2026-08-18 19:15:30 +02:00
ChatFileTokenKeyCache cryptokeys . SigningKeycache
2024-10-25 17:14:35 +01:00
Clock quartz . Clock
2026-07-20 10:30:02 +01:00
Acquirer * provisionerdserver . Acquirer
2025-03-24 16:02:33 +04:00
TelemetryReporter telemetry . Reporter
2025-08-28 15:00:26 +01:00
ProvisionerdServerMetrics * provisionerdserver . Metrics
2026-02-12 13:40:47 -08:00
WorkspaceBuilderMetrics * wsbuilder . Metrics
2026-01-27 19:01:17 -06:00
UsageInserter usage . Inserter
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
}
}
2026-01-27 19:01:17 -06:00
var usageInserter * atomic . Pointer [ usage . Inserter ]
if options . UsageInserter != nil {
usageInserter = & atomic . Pointer [ usage . Inserter ]{}
usageInserter . Store ( & options . UsageInserter )
}
2022-10-17 08:43:30 -05:00
if options . Database == nil {
2026-07-21 11:19:23 +02:00
var ps pubsub . Pubsub
options . Database , ps = dbtestutil . NewDB ( t )
var ok bool
options . ReplicaSyncPubsub , ok = ps .( * pubsub . PGPubsub )
require . True ( t , ok )
2023-01-25 21:35:53 +00:00
}
2026-06-03 15:37:19 -05:00
if options . ReplicaSyncPubsub == nil {
2026-07-21 11:19:23 +02:00
// To get here, the database must have been passed in, but not the ReplicSyncPubsub. We can't create a PGPubsub
// just from the database.Store since it could be anything including a mock. We need this to be independent from
// the main Pubsub in case it's NATS, since that uses the ReplicaSync to bootstrap the cluster. The in-mem
// pubsub satisfies these requirements.
options . ReplicaSyncPubsub = pubsub . NewInMemory ()
2026-06-03 15:37:19 -05:00
}
2026-07-21 11:19:23 +02:00
if options . Pubsub == nil {
natsCtx , natsCancel := context . WithCancel ( context . Background ())
t . Cleanup ( natsCancel )
natPS , err := natspubsub . New ( natsCtx , * options . Logger , natspubsub . Options { ClusterPort : server . RANDOM_PORT })
require . NoError ( t , err )
t . Cleanup ( func () { _ = natPS . Close () })
options . Pubsub = natPS
}
2024-08-20 17:16:49 +10:00
if options . CoordinatorResumeTokenProvider == nil {
options . CoordinatorResumeTokenProvider = tailnet . NewInsecureTestResumeTokenProvider ()
}
2023-03-21 09:10:22 -05:00
2026-08-30 13:09:17 +02:00
if options . MCPAllowedPrivateCIDRs == nil {
// Tests allow loopback for mock MCP and OAuth servers. Pass a non-nil
// allowlist, including an empty one, to exercise the guard.
options . MCPAllowedPrivateCIDRs = [] netip . Prefix {
2026-08-11 12:02:34 +02:00
netip . MustParsePrefix ( "127.0.0.0/8" ),
netip . MustParsePrefix ( "::1/128" ),
}
}
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 ,
2026-02-12 13:40:47 -08:00
options . WorkspaceBuilderMetrics ,
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
2026-02-27 00:07:14 +11:00
const derpMeshKey = "test-key"
// Technically AGPL coderd servers don't set this value, but it doesn't
// change any behavior. It's useful for enterprise tests.
err = options . Database . InsertDERPMeshKey ( dbauthz . AsSystemRestricted ( ctx ), derpMeshKey ) //nolint:gocritic // test
if ! database . IsUniqueViolation ( err , database . UniqueSiteConfigsKeyKey ) {
require . NoError ( t , err , "insert DERP mesh key" )
}
var derpServer * derp . Server
if options . DeploymentValues . DERP . Server . Enable . Value () {
derpServer = derp . NewServer ( key . NewNode (), tailnet . Logger ( options . Logger . Named ( "derp" ). Leveled ( slog . LevelDebug )))
derpServer . SetMeshKey ( derpMeshKey )
}
2022-10-17 08:43:30 -05:00
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" ,
2026-09-16 15:35:51 -07:00
// Skip the IPv6 dial. The server only listens on IPv4, and the
// failed IPv6 dial can leave a goroutine behind that goleak reports.
IPv6 : "none" ,
2023-06-22 08:02:05 +10:00
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
}
2026-04-28 09:17:08 -07:00
derpConfigURL := options . DeploymentValues . DERP . Config . URL . Value ()
derpConfigPath := options . DeploymentValues . DERP . Config . Path . Value ()
var derpMap * tailcfg . DERPMap
if region == nil && derpConfigURL == "" && derpConfigPath == "" {
derpMap = & tailcfg . DERPMap { Regions : map [ int ] * tailcfg . DERPRegion {}}
} else {
derpMap , err = tailnet . NewDERPMap (
ctx , region , stunAddresses ,
derpConfigURL , derpConfigPath ,
options . DeploymentValues . DERP . Config . BlockDirect . Value (),
)
require . NoError ( t , err )
}
2023-06-22 08:02:05 +10:00
2026-11-13 17:20:31 +01:00
// shim in the health report for the pubsub, if our original pubsub doesn't support it.
// PGPubsub, NATS, and the inmemory pubsub all do, but if a specific test adds a mock, then maybe it won't.
var rps pubsub . ReportingPubsub
rps , ok = options . Pubsub .( pubsub . ReportingPubsub )
if ! ok {
rps = testReportingPubsub { options . Pubsub }
}
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.
2026-08-30 13:09:17 +02:00
AgentInactiveDisconnectTimeout : testutil . WaitShort ,
MCPAllowedPrivateCIDRs : options . MCPAllowedPrivateCIDRs ,
ChatWorkerDisabled : options . ChatWorkerDisabled ,
AccessURL : accessURL ,
AppHostname : options . AppHostname ,
AppHostnameRegex : appHostnameRegex ,
Logger : * options . Logger ,
CacheDir : cacheDir ,
RuntimeConfig : runtimeManager ,
Database : options . Database ,
2026-11-13 17:20:31 +01:00
Pubsub : rps ,
2026-08-30 13:09:17 +02:00
ReplicaSyncPubsub : options . ReplicaSyncPubsub ,
ExternalAuthConfigs : options . ExternalAuthConfigs ,
UsageInserter : usageInserter ,
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 ,
2026-01-22 22:47:49 -08:00
MetadataBatcherOptions : options . MetadataBatcherOptions ,
2023-08-16 15:22:00 +03:00
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 ,
2026-07-20 10:30:02 +01:00
Acquirer : options . Acquirer ,
2024-10-25 17:14:35 +01:00
AppEncryptionKeyCache : options . APIKeyEncryptionCache ,
OIDCConvertKeyCache : options . OIDCConvertKeyCache ,
2026-08-18 19:15:30 +02:00
ChatFileTokenKeyCache : options . ChatFileTokenKeyCache ,
2025-08-28 15:00:26 +01:00
ProvisionerdServerMetrics : options . ProvisionerdServerMetrics ,
2026-02-12 13:40:47 -08:00
WorkspaceBuilderMetrics : options . WorkspaceBuilderMetrics ,
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
}
2026-05-11 11:03:38 +02:00
client := codersdk . New ( serverURL , codersdk . WithHTTPClient ( NewIsolatedHTTPClient ( 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
}
2026-05-11 11:03:38 +02:00
// NewIsolatedHTTPClient returns a test client with its own transport.
// Closing idle connections at test cleanup must not close http.DefaultTransport
// while another parallel test is using it.
func NewIsolatedHTTPClient ( serverURL * url . URL ) * http . Client {
transport := & http . Transport { Proxy : http . ProxyFromEnvironment }
if defaultTransport , ok := http . DefaultTransport .( * http . Transport ); ok {
transport = defaultTransport . Clone ()
}
if serverURL == nil || serverURL . Scheme != "https" {
transport . TLSClientConfig = nil
return & http . Client { Transport : transport }
}
if transport . TLSClientConfig == nil {
transport . TLSClientConfig = & tls . Config { MinVersion : tls . VersionTLS12 }
}
if transport . TLSClientConfig . MinVersion == 0 {
transport . TLSClientConfig . MinVersion = tls . VersionTLS12
}
//nolint:gosec // The coderdtest server uses test-only TLS certificates.
transport . TLSClientConfig . InsecureSkipVerify = true
return & http . Client { Transport : transport }
}
// newHTTPClientWithTransportFrom returns a fresh client that shares the base
// transport without sharing mutable per-client state like CheckRedirect.
func newHTTPClientWithTransportFrom ( base * http . Client ) * http . Client {
if base == nil {
return NewIsolatedHTTPClient ( nil )
}
if base . Transport == nil {
client := NewIsolatedHTTPClient ( nil )
client . Timeout = base . Timeout
return client
}
return & http . Client {
Transport : base . Transport ,
Timeout : base . Timeout ,
}
}
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
}
2026-01-12 18:19:19 -08:00
// AuthzUserSubject does not include the user's groups or the org-member role
// (which is a db-backed system role).
func AuthzUserSubject ( user codersdk . User ) 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
}
return rbac . Subject {
ID : user . ID . String (),
Roles : roles ,
Groups : [] string {},
Scope : rbac . ScopeAll ,
}
}
2026-01-12 18:19:19 -08:00
// AuthzUserSubjectWithDB is like AuthzUserSubject but adds db-backed roles
// (like organization-member).
func AuthzUserSubjectWithDB ( ctx context . Context , t testing . TB , db database . Store , user codersdk . User ) rbac . Subject {
t . Helper ()
roles := make ( rbac . RoleIdentifiers , 0 , len ( user . Roles ) + 2 )
// Member role is always implied
roles = append ( roles , rbac . RoleMember ())
for _ , r := range user . Roles {
parsedOrgID , _ := uuid . Parse ( r . OrganizationID ) // defaults to nil
roles = append ( roles , rbac . RoleIdentifier {
Name : r . Name ,
OrganizationID : parsedOrgID ,
})
}
//nolint:gocritic // We’ re constructing the subject. The incoming ctx
// typically has no dbauthz actor yet, and using AuthzUserSubject(user)
// here would be circular (it lacks DB-backed org-member roles needed for
// organization:read). Use system-restricted ctx for the membership lookup.
orgs , err := db . GetOrganizationsByUserID ( dbauthz . AsSystemRestricted ( ctx ), database . GetOrganizationsByUserIDParams {
UserID : user . ID ,
Deleted : sql . NullBool {
Valid : true ,
Bool : false ,
},
})
require . NoError ( t , err )
for _ , org := range orgs {
roles = append ( roles , rbac . ScopedRoleOrgMember ( org . ID ))
2026-06-05 15:01:45 -05:00
// The implicit role set (organization-member plus the org's
// default_org_member_roles) is unioned at request time by
// GetAuthorizationUserRoles. Subjects built directly here bypass
// that SQL union, so mirror it explicitly.
for _ , name := range org . DefaultOrgMemberRoles {
roles = append ( roles , rbac . RoleIdentifier {
Name : name ,
OrganizationID : org . ID ,
})
}
2026-01-12 18:19:19 -08:00
}
//nolint:gocritic // We need to expand DB-backed/system roles. The caller
// ctx may not have permission to read system roles, so use system-restricted
// context for the internal role lookup.
rbacRoles , err := rolestore . Expand ( dbauthz . AsSystemRestricted ( ctx ), db , roles )
require . NoError ( t , err )
return rbac . Subject {
ID : user . ID . String (),
Roles : rbacRoles ,
Groups : [] string {},
Scope : rbac . ScopeAll ,
}. WithCachedASTValue ()
}
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 {
2026-01-09 15:40:26 -07:00
Email : namesgenerator . UniqueName () + "@coder.com" ,
2024-08-23 16:23:51 -05:00
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.
2026-08-26 11:57:56 -06:00
UserStatus : new ( 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
2026-03-17 12:16:43 -07:00
// Service accounts cannot have a password or email and must
// use login_type=none. Enforce this after mutators so callers
// only need to set ServiceAccount=true.
if req . ServiceAccount {
req . Password = ""
req . Email = ""
req . UserLoginType = codersdk . LoginTypeNone
}
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
2026-03-20 12:43:03 -08:00
switch req . UserLoginType {
case codersdk . LoginTypeNone , codersdk . LoginTypeGithub , codersdk . LoginTypeOIDC :
// Cannot log in with a non-password user. So make it an api key from the
// client making this user.
2023-06-14 12:48:43 -05:00
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
2026-03-20 12:43:03 -08:00
default :
2023-08-10 20:04:35 -05:00
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 )
}
2026-05-11 11:03:38 +02:00
other := codersdk . New (
client . URL ,
codersdk . WithSessionToken ( sessionToken ),
codersdk . WithHTTPClient ( newHTTPClientWithTransportFrom ( client . HTTPClient )),
)
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
}
2026-02-03 17:52:07 +00:00
user , err = client . UpdateUserRoles ( context . Background (), user . ID . String (), codersdk . UpdateRoles { Roles : slice . 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 (),
2026-02-03 17:52:07 +00:00
codersdk . UpdateRoles { Roles : slice . 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
2026-06-29 09:56:42 -05:00
// from cancelation, an error, or from completing successfully. The wait is bounded by
// testutil.WaitLong; use AwaitTemplateVersionJobCompletedWithTimeout to wait longer.
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 ()
2026-06-29 09:56:42 -05:00
return AwaitTemplateVersionJobCompletedWithTimeout ( t , client , version , testutil . WaitLong )
}
2022-07-22 20:02:49 +03:00
2026-06-29 09:56:42 -05:00
// AwaitTemplateVersionJobCompletedWithTimeout waits up to timeout for the template
// version build job to complete, polling at testutil.IntervalFast. Transient API errors
// are logged and retried. Fails the test if the job does not complete in time.
func AwaitTemplateVersionJobCompletedWithTimeout ( t testing . TB , client * codersdk . Client , version uuid . UUID , timeout time . Duration ) codersdk . TemplateVersion {
t . Helper ()
ctx := testutil . Context ( t , timeout )
2022-12-13 21:28:07 +02:00
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
2026-06-29 09:56:42 -05:00
completed := testutil . Eventually ( ctx , t , func ( ctx context . Context ) 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 )
2026-06-29 09:56:42 -05:00
if err != nil {
t . Logf ( "failed to get template version %s: %v" , version , err )
return false
}
2023-10-05 10:49:25 -06:00
t . Logf ( "template version job status: %s" , templateVersion . Job . Status )
2026-06-29 09:56:42 -05:00
return templateVersion . Job . CompletedAt != nil
}, testutil . IntervalFast , "make sure you set `IncludeProvisionerDaemon`!" )
if ! completed {
t . FailNow ()
}
2023-10-05 10:49:25 -06:00
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
}
2026-06-29 09:56:42 -05:00
// AwaitWorkspaceBuildJobCompleted waits for a workspace provision job to reach completed
// status. The wait is bounded by testutil.WaitMedium; use
// AwaitWorkspaceBuildJobCompletedWithTimeout to wait longer.
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 ()
2026-06-29 09:56:42 -05:00
return AwaitWorkspaceBuildJobCompletedWithTimeout ( t , client , build , testutil . WaitMedium )
}
2022-07-22 20:02:49 +03:00
2026-06-29 09:56:42 -05:00
// AwaitWorkspaceBuildJobCompletedWithTimeout waits up to timeout for a workspace
// provision job to reach completed status, polling at testutil.IntervalFast. Transient
// API errors are logged and retried. Fails the test if the job does not complete in time.
func AwaitWorkspaceBuildJobCompletedWithTimeout ( t testing . TB , client * codersdk . Client , build uuid . UUID , timeout time . Duration ) codersdk . WorkspaceBuild {
t . Helper ()
ctx := testutil . Context ( t , timeout )
2022-12-13 21:28:07 +02:00
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
2026-06-29 09:56:42 -05:00
completed := testutil . Eventually ( ctx , t , func ( ctx context . Context ) 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
2026-06-29 09:56:42 -05:00
}, testutil . IntervalFast , "workspace build %s did not complete" , build )
if ! completed {
t . FailNow ()
}
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 ,
}
}
2026-05-22 13:55:21 +01:00
// RequireWorkspaceAgentByName avoids weak nil UUID assertions when a fixture requires a specific agent.
func RequireWorkspaceAgentByName ( t testing . TB , resources [] codersdk . WorkspaceResource , name string ) codersdk . WorkspaceAgent {
t . Helper ()
for _ , resource := range resources {
for _ , agent := range resource . Agents {
if agent . Name == name {
return agent
}
}
}
require . FailNowf ( t , "workspace agent not found" , "workspace agent %q not found in resources" , name )
return codersdk . WorkspaceAgent {}
}
2024-01-30 07:44:47 +04:00
// 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
}
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
2026-03-03 08:48:58 -05:00
}, testutil . IntervalFast )
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 )
2026-03-03 08:48:58 -05:00
}, testutil . IntervalFast )
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 ),
2026-08-26 11:57:56 -06:00
AutostartSchedule : new ( "CRON_TZ=US/Central 30 9 * * 1-5" ),
TTLMillis : new (( 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
2026-09-24 14:41:32 -04:00
func NewGoogleInstanceIdentity ( t testing . TB , instanceID string , expired bool , audience string ) ( * idtoken . Validator , * metadata . Client ) {
2022-03-25 13:48:08 -06:00
keyID , err := cryptorand . String ( 12 )
require . NoError ( t , err )
claims := jwt . MapClaims {
2026-09-24 14:41:32 -04:00
"aud" : audience ,
2022-03-25 13:48:08 -06:00
"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 )
}
}),
}
}
2026-05-13 16:14:07 +02:00
// NewAzureInstanceIdentity returns a metadata client and ID token
// validator for faking instance authentication for Azure. It builds
// a realistic 3-level certificate chain (Root CA -> Intermediate ->
// Signing Cert) to match the real Azure trust hierarchy.
func NewAzureInstanceIdentity ( t testing . TB , instanceID string ) ( azureidentity . Options , * http . Client ) {
// Root CA (self-signed, trusted).
rootKey , err := rsa . GenerateKey ( rand . Reader , 2048 )
require . NoError ( t , err )
rootTmpl := & x509 . Certificate {
SerialNumber : big . NewInt ( 1 ),
Subject : pkix . Name { CommonName : "Test Root CA" },
NotBefore : time . Now (). Add ( - time . Hour ),
NotAfter : time . Now (). AddDate ( 10 , 0 , 0 ),
IsCA : true ,
BasicConstraintsValid : true ,
KeyUsage : x509 . KeyUsageCertSign | x509 . KeyUsageCRLSign ,
}
rootDER , err := x509 . CreateCertificate ( rand . Reader , rootTmpl , rootTmpl , & rootKey . PublicKey , rootKey )
require . NoError ( t , err )
rootCert , err := x509 . ParseCertificate ( rootDER )
2022-04-19 08:48:13 -05:00
require . NoError ( t , err )
2026-05-13 16:14:07 +02:00
// Intermediate CA (signed by root).
interKey , err := rsa . GenerateKey ( rand . Reader , 2048 )
require . NoError ( t , err )
interTmpl := & x509 . Certificate {
SerialNumber : big . NewInt ( 2 ),
Subject : pkix . Name { CommonName : "Test Intermediate CA" },
NotBefore : time . Now (). Add ( - time . Hour ),
NotAfter : time . Now (). AddDate ( 5 , 0 , 0 ),
IsCA : true ,
BasicConstraintsValid : true ,
KeyUsage : x509 . KeyUsageCertSign | x509 . KeyUsageCRLSign ,
}
interDER , err := x509 . CreateCertificate ( rand . Reader , interTmpl , rootCert , & interKey . PublicKey , rootKey )
require . NoError ( t , err )
interCert , err := x509 . ParseCertificate ( interDER )
require . NoError ( t , err )
// Signing cert (leaf, signed by intermediate).
signKey , err := rsa . GenerateKey ( rand . Reader , 2048 )
require . NoError ( t , err )
signTmpl := & x509 . Certificate {
SerialNumber : big . NewInt ( 3 ),
Subject : pkix . Name { CommonName : "metadata.azure.com" },
NotBefore : time . Now (). Add ( - time . Hour ),
2022-04-19 08:48:13 -05:00
NotAfter : time . Now (). AddDate ( 1 , 0 , 0 ),
2026-05-13 16:14:07 +02:00
}
signDER , err := x509 . CreateCertificate ( rand . Reader , signTmpl , interCert , & signKey . PublicKey , interKey )
2022-04-19 08:48:13 -05:00
require . NoError ( t , err )
2026-05-13 16:14:07 +02:00
signCert , err := x509 . ParseCertificate ( signDER )
2022-04-19 08:48:13 -05:00
require . NoError ( t , err )
2026-05-13 16:14:07 +02:00
// Build PKCS7 signed data with only the signing cert.
2022-04-19 08:48:13 -05:00
signed , err := pkcs7 . NewSignedData ([] byte ( `{"vmId":"` + instanceID + `"}` ))
require . NoError ( t , err )
2026-05-13 16:14:07 +02:00
err = signed . AddSigner ( signCert , signKey , pkcs7 . SignerInfoConfig {})
2022-04-19 08:48:13 -05:00
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 )
2026-05-13 16:14:07 +02:00
roots := x509 . NewCertPool ()
roots . AddCert ( rootCert )
2022-04-19 08:48:13 -05:00
2026-05-13 16:14:07 +02:00
return azureidentity . Options {
Roots : roots ,
Intermediates : [] * x509 . Certificate { interCert },
2022-04-19 08:48:13 -05:00
}, & 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 )
}
}),
}
}
2026-01-09 15:40:26 -07:00
func RandomUsername ( _ testing . TB ) string {
return namesgenerator . UniqueNameWith ( "-" )
2022-01-20 07:46:51 -06:00
}
2022-03-25 13:48:08 -06:00
2026-01-09 15:40:26 -07:00
// RandomName returns a random name in title case (e.g. "Happy Einstein").
func RandomName ( _ testing . TB ) string {
return cases . Title ( language . English ). String (
namesgenerator . NameWith ( " " ),
)
2024-06-26 09:00:42 +01:00
}
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-10-30 10:23:52 -08:00
require . True ( t , errors . As ( err , & cerr ), "should be SDK error, got %s" , 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 )
2026-09-14 08:31:26 -07:00
// The OAuth2 provider is off by default in production. Tests turn it on
// so OAuth2 routes are reachable without extra setup.
cfg . OAuth2 . Provider . Enable = true
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" )
}
2026-06-05 09:55:32 -06:00
// NextAutostartTick returns workspace.NextStartAt for use as the autobuild
// tick. The executor's eligibility query checks next_start_at <= tick.
// Computing from build.CreatedAt is racy: next_start_at derives from build
// completion time, so it can advance past sched.Next(build.CreatedAt) and
// the workspace misses the eligibility window.
func NextAutostartTick ( t testing . TB , workspace codersdk . Workspace ) time . Time {
t . Helper ()
require . NotNil ( t , workspace . NextStartAt ,
"workspace next_start_at is nil; ensure autostart is enabled and the latest build has completed before calling NextAutostartTick" )
return * workspace . NextStartAt
}
2025-08-15 08:50:51 -07:00
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
}
2026-11-13 17:20:31 +01:00
type testReportingPubsub struct {
pubsub . Pubsub
}
func ( testReportingPubsub ) HealthReport ( context . Context ) healthsdk . PubsubReport {
return healthsdk . PubsubReport {
Backend : "coderd-shim" ,
BaseReport : healthsdk . BaseReport { Severity : health . SeverityOK },
}
}