2022-01-20 07:46:51 -06:00
package coderdtest
import (
2022-03-25 13:48:08 -06:00
"bytes"
2022-01-20 07:46:51 -06:00
"context"
2022-03-28 13:31:03 -06:00
"crypto"
2022-03-25 13:48:08 -06:00
"crypto/rand"
"crypto/rsa"
2022-03-28 13:31:03 -06:00
"crypto/sha256"
2022-10-17 08:43:30 -05:00
"crypto/tls"
2022-03-28 13:31:03 -06:00
"crypto/x509"
2022-04-19 08:48:13 -05:00
"crypto/x509/pkix"
2023-06-08 10:30:15 -05:00
"database/sql"
2022-03-25 13:48:08 -06:00
"encoding/base64"
"encoding/json"
2022-03-28 13:31:03 -06:00
"encoding/pem"
2022-09-06 12:07:00 -05:00
"errors"
2022-05-12 15:56:23 -05:00
"fmt"
2022-02-03 14:34:50 -06:00
"io"
2022-03-25 13:48:08 -06:00
"math/big"
2022-02-18 22:06:56 -06:00
"net"
2022-03-25 13:48:08 -06:00
"net/http"
2022-01-20 07:46:51 -06:00
"net/http/httptest"
"net/url"
2022-10-15 04:25:11 +10:00
"regexp"
2022-08-31 20:09:44 -05:00
"strconv"
2022-02-05 18:24:51 -06:00
"strings"
2022-10-17 08:43:30 -05:00
"sync"
2023-04-04 22:48:35 +10:00
"sync/atomic"
2022-01-20 07:46:51 -06:00
"testing"
2022-02-03 14:34:50 -06:00
"time"
2022-01-20 07:46:51 -06:00
2022-03-25 13:48:08 -06:00
"cloud.google.com/go/compute/metadata"
2022-10-17 22:07:11 -05:00
"github.com/coreos/go-oidc/v3/oidc"
2022-04-19 08:48:13 -05:00
"github.com/fullsailor/pkcs7"
2022-03-25 13:48:08 -06:00
"github.com/golang-jwt/jwt"
2022-02-05 18:24:51 -06:00
"github.com/google/uuid"
"github.com/moby/moby/pkg/namesgenerator"
2023-02-14 08:27:06 -06:00
"github.com/prometheus/client_golang/prometheus"
2022-06-24 10:25:01 -05:00
"github.com/spf13/afero"
2022-05-24 08:58:39 +01:00
"github.com/stretchr/testify/assert"
2022-01-20 07:46:51 -06:00
"github.com/stretchr/testify/require"
2022-10-17 22:07:11 -05:00
"golang.org/x/oauth2"
2022-06-29 14:17:32 -05:00
"golang.org/x/xerrors"
2022-02-21 14:36:29 -06:00
"google.golang.org/api/idtoken"
"google.golang.org/api/option"
2022-10-17 08:43:30 -05:00
"tailscale.com/derp"
2022-09-14 20:21:53 -05:00
"tailscale.com/net/stun/stuntest"
2022-08-31 20:09:44 -05:00
"tailscale.com/tailcfg"
2022-10-17 08:43:30 -05:00
"tailscale.com/types/key"
2022-09-14 20:21:53 -05:00
"tailscale.com/types/nettype"
2022-01-20 07:46:51 -06:00
2022-02-03 14:34:50 -06:00
"cdr.dev/slog"
2023-08-04 17:00:42 +01:00
"cdr.dev/slog/sloggers/sloghuman"
2022-01-20 07:46:51 -06:00
"cdr.dev/slog/sloggers/slogtest"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd"
"github.com/coder/coder/v2/coderd/audit"
"github.com/coder/coder/v2/coderd/autobuild"
"github.com/coder/coder/v2/coderd/awsidentity"
"github.com/coder/coder/v2/coderd/batchstats"
"github.com/coder/coder/v2/coderd/database"
"github.com/coder/coder/v2/coderd/database/dbauthz"
"github.com/coder/coder/v2/coderd/database/dbtestutil"
"github.com/coder/coder/v2/coderd/database/pubsub"
"github.com/coder/coder/v2/coderd/gitauth"
"github.com/coder/coder/v2/coderd/gitsshkey"
"github.com/coder/coder/v2/coderd/healthcheck"
"github.com/coder/coder/v2/coderd/httpapi"
"github.com/coder/coder/v2/coderd/httpmw"
"github.com/coder/coder/v2/coderd/rbac"
"github.com/coder/coder/v2/coderd/schedule"
"github.com/coder/coder/v2/coderd/telemetry"
"github.com/coder/coder/v2/coderd/unhanger"
"github.com/coder/coder/v2/coderd/updatecheck"
"github.com/coder/coder/v2/coderd/util/ptr"
"github.com/coder/coder/v2/coderd/workspaceapps"
"github.com/coder/coder/v2/codersdk"
"github.com/coder/coder/v2/codersdk/agentsdk"
"github.com/coder/coder/v2/cryptorand"
"github.com/coder/coder/v2/provisioner/echo"
"github.com/coder/coder/v2/provisionerd"
provisionerdproto "github.com/coder/coder/v2/provisionerd/proto"
"github.com/coder/coder/v2/provisionersdk"
sdkproto "github.com/coder/coder/v2/provisionersdk/proto"
"github.com/coder/coder/v2/tailnet"
"github.com/coder/coder/v2/testutil"
2022-01-20 07:46:51 -06:00
)
2023-04-06 04:41:55 +10:00
// AppSecurityKey is a 96-byte key used to sign JWTs and encrypt JWEs for
// workspace app tokens in tests.
var AppSecurityKey = must ( workspaceapps . KeyFromString ( "6465616e207761732068657265206465616e207761732068657265206465616e207761732068657265206465616e207761732068657265206465616e207761732068657265206465616e207761732068657265206465616e2077617320686572" ))
2023-03-08 06:38:11 +11:00
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).
2023-03-08 01:14:58 +11:00
AccessURL * url . URL
AppHostname string
AWSCertificates awsidentity . Certificates
Authorizer rbac . Authorizer
AzureCertificates x509 . VerifyOptions
GithubOAuth2Config * coderd . GithubOAuth2Config
RealIPConfig * httpmw . RealIPConfig
OIDCConfig * coderd . OIDCConfig
GoogleTokenValidator * idtoken . Validator
SSHKeygenAlgorithm gitsshkey . Algorithm
AutobuildTicker <- chan time . Time
2023-06-22 00:33:22 -04:00
AutobuildStats chan <- autobuild . Stats
2023-03-08 01:14:58 +11:00
Auditor audit . Auditor
TLSCertificates [] tls . Certificate
GitAuthConfigs [] * gitauth . Config
TrialGenerator func ( context . Context , string ) error
TemplateScheduleStore schedule . TemplateScheduleStore
2023-07-12 17:37:31 -05:00
Coordinator tailnet . Coordinator
2022-05-19 15:47:45 -07:00
2023-06-01 19:21:24 -05:00
HealthcheckFunc func ( ctx context . Context , apiKey string ) * healthcheck . Report
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
2022-09-04 11:28:09 -05:00
// IncludeProvisionerDaemon when true means to start an in-memory provisionerD
2022-09-06 12:07:00 -05:00
IncludeProvisionerDaemon bool
MetricsCacheRefreshInterval time . Duration
AgentStatsRefreshInterval time . Duration
2023-03-07 15:10:01 -06:00
DeploymentValues * codersdk . DeploymentValues
2022-10-17 08:43:30 -05:00
2022-12-01 19:43:28 +02:00
// Set update check options to enable update check.
UpdateCheckOptions * updatecheck . Options
2022-10-17 08:43:30 -05:00
// Overriding the database is heavily discouraged.
// It should only be used in cases where multiple Coder
// test instances are running against the same database.
Database database . Store
2023-06-14 10:34:54 -05:00
Pubsub pubsub . Pubsub
2022-12-19 18:43:46 +01:00
2023-03-16 13:03:37 -05:00
ConfigSSH codersdk . SSHConfigResponse
2022-12-19 18:43:46 +01:00
SwaggerEndpoint bool
2023-06-22 00:33:22 -04:00
// Logger should only be overridden if you expect errors
// as part of your test.
2023-08-04 17:00:42 +01:00
Logger * slog . Logger
StatsBatcher * batchstats . Batcher
2023-08-16 15:22:00 +03:00
WorkspaceAppsStatsCollectorOptions workspaceapps . StatsCollectorOptions
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
}
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.
func NewWithProvisionerCloser ( t * testing . T , options * Options ) ( * codersdk . Client , io . Closer ) {
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 {}
}
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 {
2023-05-08 08:59:01 -05:00
defAuth := rbac . NewCachingAuthorizer ( prometheus . NewRegistry ())
if _ , ok := t .( * testing . T ); ok {
options . Authorizer = & RecordingAuthorizer {
Wrapped : defAuth ,
}
} else {
// In benchmarks, the recording authorizer greatly skews results.
options . Authorizer = defAuth
2023-03-21 09:10:22 -05:00
}
}
2022-10-17 08:43:30 -05:00
if options . Database == nil {
options . Database , options . Pubsub = dbtestutil . NewDB ( t )
2023-02-14 08:27:06 -06:00
options . Database = dbauthz . New ( options . Database , options . Authorizer , slogtest . Make ( t , nil ). Leveled ( slog . LevelDebug ))
2023-01-25 21:35:53 +00:00
}
2023-03-21 09:10:22 -05:00
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" )
}
2023-03-07 15:10:01 -06:00
if options . DeploymentValues == nil {
options . DeploymentValues = DeploymentValues ( t )
2022-11-08 11:59:39 -05:00
}
2023-04-11 08:57:23 -05:00
// This value is not safe to run in parallel. Force it to be false.
options . DeploymentValues . DisableOwnerWorkspaceExec = false
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 )
batcher , closeBatcher , err := batchstats . New ( ctx ,
batchstats . WithStore ( options . Database ),
// Avoid cluttering up test output.
batchstats . WithLogger ( slog . Make ( sloghuman . Sink ( io . Discard ))),
)
require . NoError ( t , err , "create stats batcher" )
options . StatsBatcher = batcher
t . Cleanup ( closeBatcher )
}
2023-01-05 12:05:20 -06:00
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 )
2022-04-18 17:40:25 -05:00
ctx , cancelFunc := context . WithCancel ( context . Background ())
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-04-04 22:48:35 +10:00
& templateScheduleStore ,
2022-05-11 23:03:02 +01:00
slogtest . Make ( t , nil ). Named ( "autobuild.executor" ). Leveled ( slog . LevelDebug ),
2022-05-13 17:14:24 +01:00
options . AutobuildTicker ,
2022-05-30 20:23:36 +01:00
). WithStatsChannel ( options . AutobuildStats )
2022-05-11 23:03:02 +01:00
lifecycleExecutor . Run ()
2023-06-25 23:17:00 +10:00
hangDetectorTicker := time . NewTicker ( options . DeploymentValues . JobHangDetectorInterval . Value ())
defer hangDetectorTicker . Stop ()
hangDetector := unhanger . New ( ctx , options . Database , options . Pubsub , slogtest . Make ( t , nil ). Named ( "unhanger.detector" ), hangDetectorTicker . C )
hangDetector . Start ()
t . Cleanup ( hangDetector . Close )
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 )
}
}))
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 ()
}
2022-07-25 19:22:02 +03:00
t . Cleanup ( srv . Close )
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 )
2022-09-13 13:31:33 -04:00
serverURL . Host = fmt . Sprintf ( "localhost:%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 ()
)
if len ( dvStunAddresses ) == 0 || ( len ( dvStunAddresses ) == 1 && dvStunAddresses [ 0 ] == "stun.l.google.com:19302" ) {
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
} else if dvStunAddresses [ 0 ] != "disable" {
stunAddresses = options . DeploymentValues . DERP . Server . STUNAddresses . Value ()
}
2022-09-14 20:21:53 -05:00
2023-03-14 09:46:47 -05:00
derpServer := derp . NewServer ( key . NewNode (), tailnet . Logger ( slogtest . Make ( t , nil ). Named ( "derp" ). Leveled ( slog . LevelDebug )))
2022-10-17 08:43:30 -05:00
derpServer . SetMeshKey ( "test-key" )
2022-04-05 19:18:26 -05:00
// match default with cli default
if options . SSHKeygenAlgorithm == "" {
options . SSHKeygenAlgorithm = gitsshkey . AlgorithmEd25519
}
2022-10-15 04:25:11 +10:00
var appHostnameRegex * regexp . Regexp
if options . AppHostname != "" {
var err error
appHostnameRegex , err = httpapi . CompileHostnamePattern ( options . AppHostname )
require . NoError ( t , err )
}
2023-06-22 00:33:22 -04:00
if options . Logger == nil {
logger := slogtest . Make ( t , nil ). Leveled ( slog . LevelDebug )
options . Logger = & logger
}
2023-06-22 08:02:05 +10:00
region := & tailcfg . DERPRegion {
EmbeddedRelay : true ,
RegionID : int ( options . DeploymentValues . DERP . Server . RegionID . Value ()),
RegionCode : options . DeploymentValues . DERP . Server . RegionCode . String (),
RegionName : options . DeploymentValues . DERP . Server . RegionName . String (),
Nodes : [] * tailcfg . DERPNode {{
Name : fmt . Sprintf ( "%db" , options . DeploymentValues . DERP . Server . RegionID ),
RegionID : int ( options . DeploymentValues . DERP . Server . RegionID . Value ()),
IPv4 : "127.0.0.1" ,
DERPPort : derpPort ,
// STUN port is added as a separate node by tailnet.NewDERPMap() if
// direct connections are enabled.
STUNPort : - 1 ,
InsecureForTests : true ,
ForceHTTP : options . TLSCertificates == nil ,
}},
}
if ! options . DeploymentValues . DERP . Server . Enable . Value () {
region = nil
}
2023-08-01 08:50:43 -07:00
derpMap , err := tailnet . NewDERPMap ( ctx , region , stunAddresses , "" , "" , options . DeploymentValues . DERP . Config . BlockDirect . Value ())
2023-06-22 08:02:05 +10:00
require . NoError ( t , err )
2022-10-17 08:43:30 -05:00
return func ( h http . Handler ) {
mutex . Lock ()
defer mutex . Unlock ()
handler = h
2022-12-16 04:43:00 +10:00
}, cancelFunc , serverURL , & coderd . Options {
2022-10-17 08:43:30 -05:00
AgentConnectionUpdateFrequency : 150 * time . Millisecond ,
// Force a long disconnection timeout to ensure
// agents are not marked as disconnected during slow tests.
AgentInactiveDisconnectTimeout : testutil . WaitShort ,
2022-12-16 04:43:00 +10:00
AccessURL : accessURL ,
2022-10-17 08:43:30 -05:00
AppHostname : options . AppHostname ,
AppHostnameRegex : appHostnameRegex ,
2023-06-22 00:33:22 -04:00
Logger : * options . Logger ,
2022-10-17 08:43:30 -05:00
CacheDir : t . TempDir (),
Database : options . Database ,
Pubsub : options . Pubsub ,
2022-10-24 19:46:24 -05:00
GitAuthConfigs : options . GitAuthConfigs ,
2022-02-28 12:26:01 -06:00
2023-08-16 15:22:00 +03:00
Auditor : options . Auditor ,
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 ,
Telemetry : telemetry . NewNoop (),
TemplateScheduleStore : & templateScheduleStore ,
TLSCertificates : options . TLSCertificates ,
TrialGenerator : options . TrialGenerator ,
TailnetCoordinator : options . Coordinator ,
BaseDERPMap : derpMap ,
DERPMapUpdateFrequency : 150 * time . Millisecond ,
MetricsCacheRefreshInterval : options . MetricsCacheRefreshInterval ,
AgentStatsRefreshInterval : options . AgentStatsRefreshInterval ,
DeploymentValues : options . DeploymentValues ,
UpdateCheckOptions : options . UpdateCheckOptions ,
SwaggerEndpoint : options . SwaggerEndpoint ,
AppSecurityKey : AppSecurityKey ,
SSHConfig : options . ConfigSSH ,
HealthcheckFunc : options . HealthcheckFunc ,
HealthcheckTimeout : options . HealthcheckTimeout ,
HealthcheckRefresh : options . HealthcheckRefresh ,
StatsBatcher : options . StatsBatcher ,
WorkspaceAppsStatsCollectorOptions : options . WorkspaceAppsStatsCollectorOptions ,
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 )
2022-10-17 08:43:30 -05:00
setHandler ( coderAPI . 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 {
2022-06-27 13:50:52 -05:00
provisionerCloser = NewProvisionerDaemon ( t , coderAPI )
2022-05-19 15:47:45 -07:00
}
2022-12-16 04:43:00 +10:00
client := codersdk . New ( serverURL )
2022-02-20 16:29:16 -06:00
t . Cleanup ( func () {
2022-09-19 23:11:01 -05:00
cancelFunc ()
2022-06-27 13:50:52 -05:00
_ = provisionerCloser . Close ()
2022-09-19 23:11:01 -05:00
_ = coderAPI . Close ()
2022-11-13 14:06:03 -06:00
client . HTTPClient . CloseIdleConnections ()
2022-02-20 16:29:16 -06:00
})
2022-11-13 14:06:03 -06:00
return client , provisionerCloser , coderAPI
2022-05-17 13:43:19 -05:00
}
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 {
2023-06-13 20:18:31 +03:00
t . Helper ()
2022-11-22 12:19:32 -06:00
echoClient , echoServer := provisionersdk . MemTransportPipe ()
2022-02-05 18:24:51 -06:00
ctx , cancelFunc := context . WithCancel ( context . Background ())
t . Cleanup ( func () {
_ = echoClient . Close ()
_ = echoServer . Close ()
cancelFunc ()
})
2022-06-16 10:09:22 -05:00
fs := afero . NewMemMapFs ()
2022-02-05 18:24:51 -06:00
go func () {
2022-06-16 10:09:22 -05:00
err := echo . Serve ( ctx , fs , & provisionersdk . ServeOptions {
2022-02-05 18:24:51 -06:00
Listener : echoServer ,
})
2022-05-24 08:58:39 +01:00
assert . NoError ( t , err )
2022-02-05 18:24:51 -06:00
}()
2022-11-16 16:34:06 -06:00
closer := provisionerd . New ( func ( ctx context . Context ) ( provisionerdproto . DRPCProvisionerDaemonClient , error ) {
return coderAPI . CreateInMemoryProvisionerDaemon ( ctx , 0 )
}, & provisionerd . Options {
Filesystem : fs ,
2023-06-22 00:33:22 -04:00
Logger : coderAPI . Logger . Named ( "provisionerd" ). Leveled ( slog . LevelDebug ),
2022-12-01 16:54:53 -06:00
JobPollInterval : 50 * time . Millisecond ,
2022-11-16 16:34:06 -06:00
UpdateInterval : 250 * time . Millisecond ,
ForceCancelInterval : time . Second ,
Provisioners : provisionerd . Provisioners {
2022-11-22 12:19:32 -06:00
string ( database . ProvisionerTypeEcho ): sdkproto . NewDRPCProvisionerClient ( echoClient ),
2022-11-16 16:34:06 -06:00
},
WorkDirectory : t . TempDir (),
})
t . Cleanup ( func () {
_ = closer . Close ()
})
return closer
}
func NewExternalProvisionerDaemon ( t * testing . T , client * codersdk . Client , org uuid . UUID , tags map [ string ] string ) io . Closer {
2022-11-22 12:19:32 -06:00
echoClient , echoServer := provisionersdk . MemTransportPipe ()
2022-11-16 16:34:06 -06:00
ctx , cancelFunc := context . WithCancel ( context . Background ())
2023-02-14 16:57:48 +02:00
serveDone := make ( chan struct {})
2022-11-16 16:34:06 -06:00
t . Cleanup ( func () {
_ = echoClient . Close ()
_ = echoServer . Close ()
cancelFunc ()
2023-02-14 16:57:48 +02:00
<- serveDone
2022-11-16 16:34:06 -06:00
})
fs := afero . NewMemMapFs ()
go func () {
2023-02-14 16:57:48 +02:00
defer close ( serveDone )
2022-11-16 16:34:06 -06:00
err := echo . Serve ( ctx , fs , & provisionersdk . ServeOptions {
Listener : echoServer ,
})
assert . NoError ( t , err )
}()
closer := provisionerd . New ( func ( ctx context . Context ) ( provisionerdproto . DRPCProvisionerDaemonClient , error ) {
2023-08-04 12:32:28 +04:00
return client . ServeProvisionerDaemon ( ctx , codersdk . ServeProvisionerDaemonRequest {
Organization : org ,
Provisioners : [] codersdk . ProvisionerType { codersdk . ProvisionerTypeEcho },
Tags : tags ,
})
2022-11-10 16:37:33 -06:00
}, & provisionerd . Options {
2022-06-16 10:09:22 -05:00
Filesystem : fs ,
2022-03-22 13:17:50 -06:00
Logger : slogtest . Make ( t , nil ). Named ( "provisionerd" ). Leveled ( slog . LevelDebug ),
2022-12-01 16:54:53 -06:00
JobPollInterval : 50 * time . Millisecond ,
2022-09-04 11:28:09 -05:00
UpdateInterval : 250 * time . Millisecond ,
2022-07-21 20:29:45 +01:00
ForceCancelInterval : time . Second ,
2022-02-05 18:24:51 -06:00
Provisioners : provisionerd . Provisioners {
2022-11-22 12:19:32 -06:00
string ( database . ProvisionerTypeEcho ): sdkproto . NewDRPCProvisionerClient ( echoClient ),
2022-02-05 18:24:51 -06:00
},
WorkDirectory : t . TempDir (),
})
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!" ,
2022-05-06 09:20:08 -05:00
}
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.
2023-02-06 17:48:21 -06:00
func CreateAnotherUser ( t * testing . T , client * codersdk . Client , organizationID uuid . UUID , roles ... string ) ( * codersdk . Client , codersdk . User ) {
2023-06-14 12:48:43 -05:00
return createAnotherUserRetry ( t , client , organizationID , 5 , roles )
2022-06-29 14:17:32 -05:00
}
2023-06-14 12:48:43 -05:00
func CreateAnotherUserMutators ( t * testing . T , client * codersdk . Client , organizationID uuid . UUID , roles [] string , mutators ... func ( r * codersdk . CreateUserRequest )) ( * codersdk . Client , codersdk . User ) {
return createAnotherUserRetry ( t , client , organizationID , 5 , roles , mutators ... )
}
func createAnotherUserRetry ( t * testing . T , client * codersdk . Client , organizationID uuid . UUID , retries int , roles [] string , mutators ... func ( r * codersdk . CreateUserRequest )) ( * codersdk . Client , codersdk . User ) {
2022-03-22 13:17:50 -06:00
req := codersdk . CreateUserRequest {
2022-07-20 18:03:04 +03:00
Email : namesgenerator . GetRandomName ( 10 ) + "@coder.com" ,
2023-04-06 11:53:02 -05:00
Username : randomUsername ( t ),
2023-02-08 14:10:08 -06:00
Password : "SomeSecurePassword!" ,
2022-04-01 14:42:36 -05:00
OrganizationID : organizationID ,
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
2022-05-12 15:56:23 -05:00
user , err := client . CreateUser ( 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 --
2023-06-14 12:48:43 -05:00
return createAnotherUserRetry ( t , client , organizationID , 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
2023-08-10 20:04:35 -05:00
if req . DisableLogin || req . UserLoginType == codersdk . LoginTypeNone {
2023-06-14 12:48:43 -05:00
// Cannot log in with a disabled login user. So make it an api key from
// the client making this user.
token , err := client . CreateToken ( context . Background (), user . ID . String (), codersdk . CreateTokenRequest {
Lifetime : time . Hour * 24 ,
Scope : codersdk . APIKeyScopeAll ,
TokenName : "no-password-user-token" ,
})
require . NoError ( t , err )
sessionToken = token . Key
2023-08-10 20:04:35 -05:00
} else {
login , err := client . LoginWithPassword ( context . Background (), codersdk . LoginWithPasswordRequest {
Email : req . Email ,
Password : req . Password ,
})
require . NoError ( t , err )
sessionToken = login . SessionToken
2023-06-14 12:48:43 -05:00
}
2022-03-07 11:40:54 -06:00
2023-08-02 16:31:25 +02:00
if user . Status == codersdk . UserStatusDormant {
// Use admin client so that user's LastSeenAt is not updated.
// In general we need to refresh the user status, which should
// transition from "dormant" to "active".
user , err = client . User ( context . Background (), user . Username )
require . NoError ( t , err )
}
2022-03-07 11:40:54 -06:00
other := codersdk . New ( client . URL )
2023-06-14 12:48:43 -05:00
other . SetSessionToken ( sessionToken )
2023-02-25 16:01:01 -06:00
t . Cleanup ( func () {
other . HTTPClient . CloseIdleConnections ()
})
2022-05-12 15:56:23 -05:00
if len ( roles ) > 0 {
// Find the roles for the org vs the site wide roles
orgRoles := make ( map [ string ][] string )
var siteRoles [] string
for _ , roleName := range roles {
roleName := roleName
orgID , ok := rbac . IsOrgRole ( roleName )
if ok {
orgRoles [ orgID ] = append ( orgRoles [ orgID ], roleName )
} else {
siteRoles = append ( siteRoles , roleName )
}
}
// Update the roles
for _ , r := range user . Roles {
siteRoles = append ( siteRoles , r . Name )
}
2022-05-17 13:43:19 -05:00
_ , err := client . UpdateUserRoles ( context . Background (), user . ID . String (), codersdk . UpdateRoles { Roles : siteRoles })
2022-05-12 15:56:23 -05:00
require . NoError ( t , err , "update site roles" )
// Update org roles
for orgID , roles := range orgRoles {
organizationID , err := uuid . Parse ( orgID )
require . NoError ( t , err , fmt . Sprintf ( "parse org id %q" , orgID ))
2022-05-25 11:00:59 -05:00
_ , err = client . UpdateOrganizationMemberRoles ( context . Background (), organizationID , user . ID . String (),
2022-06-01 09:07:50 -05:00
codersdk . UpdateRoles { Roles : roles })
2022-05-12 15:56:23 -05:00
require . NoError ( t , err , "update org membership roles" )
}
}
2022-08-09 13:16:53 -05:00
return other , user
2022-03-07 11:40:54 -06:00
}
2022-04-06 12:42:40 -05:00
// CreateTemplateVersion creates a template import provisioner job
2022-02-08 12:00:44 -06:00
// with the responses provided. It uses the "echo" provisioner for compatibility
// with testing.
2023-02-15 18:24:15 +01:00
func CreateTemplateVersion ( t * testing . T , client * codersdk . Client , organizationID uuid . UUID , res * echo . Responses , mutators ... func ( * codersdk . CreateTemplateVersionRequest )) codersdk . TemplateVersion {
2022-10-10 15:37:06 -05:00
t . Helper ()
2022-02-08 12:00:44 -06:00
data , err := echo . Tar ( res )
require . NoError ( t , err )
2023-02-04 14:07:09 -06:00
file , err := client . Upload ( context . Background (), codersdk . ContentTypeTar , 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
}
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 {
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.
2022-06-07 13:37:45 +01:00
func CreateTemplate ( t * testing . T , client * codersdk . Client , organization uuid . UUID , version uuid . UUID , mutators ... func ( * codersdk . CreateTemplateRequest )) codersdk . Template {
req := codersdk . CreateTemplateRequest {
2023-04-20 10:59:57 -07:00
Name : randomUsername ( t ),
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
}
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.
func UpdateTemplateVersion ( t * testing . T , client * codersdk . Client , organizationID uuid . UUID , res * echo . Responses , templateID uuid . UUID ) codersdk . TemplateVersion {
data , err := echo . Tar ( res )
require . NoError ( t , err )
2023-02-04 14:07:09 -06:00
file , err := client . Upload ( context . Background (), codersdk . ContentTypeTar , bytes . NewReader ( data ))
2022-05-11 23:03:02 +01:00
require . NoError ( t , err )
templateVersion , err := client . CreateTemplateVersion ( context . Background (), organizationID , codersdk . CreateTemplateVersionRequest {
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
}
2022-04-06 12:42:40 -05:00
// AwaitTemplateImportJob awaits for an import job to reach completed status.
func AwaitTemplateVersionJob ( t * testing . T , client * codersdk . Client , version uuid . UUID ) codersdk . TemplateVersion {
2022-07-22 20:02:49 +03:00
t . Helper ()
2022-12-13 21:28:07 +02:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitMedium )
defer cancel ()
2022-07-01 09:55:46 -07:00
t . Logf ( "waiting for template version job %s" , version )
2022-04-06 12:42:40 -05:00
var templateVersion codersdk . TemplateVersion
2022-09-04 11:28:09 -05:00
require . Eventually ( t , func () bool {
2022-02-05 18:24:51 -06:00
var err error
2022-12-13 21:28:07 +02:00
templateVersion , err = client . TemplateVersion ( ctx , version )
2022-07-22 20:02:49 +03:00
return assert . NoError ( t , err ) && templateVersion . Job . CompletedAt != nil
2022-10-17 08:43:30 -05:00
}, testutil . WaitMedium , testutil . IntervalFast )
2022-12-13 21:28:07 +02:00
t . Logf ( "got template version job %s" , version )
2022-04-06 12:42:40 -05:00
return templateVersion
2022-02-12 13:34:04 -06:00
}
2022-03-07 11:40:54 -06:00
// AwaitWorkspaceBuildJob waits for a workspace provision job to reach completed status.
2022-03-22 13:17:50 -06:00
func AwaitWorkspaceBuildJob ( t * testing . T , client * codersdk . Client , build uuid . UUID ) codersdk . WorkspaceBuild {
2022-07-22 20:02:49 +03:00
t . Helper ()
2022-12-13 21:28:07 +02:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
2022-07-22 20:02:49 +03:00
t . Logf ( "waiting for workspace build job %s" , build )
2022-03-22 13:17:50 -06:00
var workspaceBuild codersdk . WorkspaceBuild
2022-09-04 11:28:09 -05:00
require . Eventually ( t , func () bool {
2022-11-14 11:57:33 -06:00
var err error
2022-12-13 21:28:07 +02:00
workspaceBuild , err = client . WorkspaceBuild ( ctx , build )
2022-07-22 20:02:49 +03:00
return assert . NoError ( t , err ) && workspaceBuild . Job . CompletedAt != nil
2022-09-04 11:28:09 -05:00
}, testutil . WaitShort , testutil . IntervalFast )
2022-12-13 21:28:07 +02:00
t . Logf ( "got workspace build job %s" , build )
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.
func AwaitWorkspaceAgents ( t * testing . T , client * codersdk . Client , workspaceID uuid . UUID , agentNames ... string ) [] codersdk . WorkspaceResource {
2022-07-22 20:02:49 +03:00
t . Helper ()
2023-03-31 00:24:51 +11:00
agentNamesMap := make ( map [ string ] struct {}, len ( agentNames ))
for _ , name := range agentNames {
agentNamesMap [ name ] = struct {}{}
}
2022-12-13 21:28:07 +02:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2022-10-03 17:01:13 -04:00
t . Logf ( "waiting for workspace agents (workspace %s)" , workspaceID )
2022-03-22 13:17:50 -06:00
var resources [] codersdk . WorkspaceResource
2022-09-04 11:28:09 -05:00
require . Eventually ( t , func () bool {
2022-03-07 11:40:54 -06:00
var err error
2022-12-13 21:28:07 +02:00
workspace , err := client . Workspace ( ctx , workspaceID )
2022-07-22 20:02:49 +03:00
if ! assert . NoError ( t , err ) {
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 {
2023-03-31 00:24:51 +11:00
if len ( agentNames ) > 0 {
if _ , ok := agentNamesMap [ agent . Name ]; ! ok {
continue
}
}
2022-04-11 18:54:30 -05:00
if agent . Status != codersdk . WorkspaceAgentConnected {
2022-08-05 16:34:44 +01:00
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
2022-03-07 11:40:54 -06:00
return true
2022-09-04 11:28:09 -05:00
}, testutil . WaitLong , testutil . IntervalFast )
2022-12-13 21:28:07 +02:00
t . Logf ( "got workspace agents (workspace %s)" , 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.
func CreateWorkspace ( t * testing . T , client * codersdk . Client , organization uuid . UUID , templateID uuid . UUID , mutators ... func ( * codersdk . CreateWorkspaceRequest )) codersdk . Workspace {
t . Helper ()
req := codersdk . CreateWorkspaceRequest {
TemplateID : templateID ,
2023-04-06 11:53:02 -05:00
Name : randomUsername ( t ),
2022-06-07 13:37:45 +01:00
AutostartSchedule : ptr . Ref ( "CRON_TZ=US/Central 30 9 * * 1-5" ),
2022-06-02 11:23:34 +01:00
TTLMillis : ptr . Ref (( 8 * time . Hour ). Milliseconds ()),
2022-05-23 23:31:41 +01:00
}
for _ , mutator := range mutators {
mutator ( & req )
}
2022-09-23 20:17:10 -05:00
workspace , err := client . CreateWorkspace ( context . Background (), organization , 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.
func MustTransitionWorkspace ( t * testing . T , client * codersdk . Client , workspaceID uuid . UUID , from , to database . WorkspaceTransition ) codersdk . Workspace {
t . Helper ()
ctx := context . Background ()
workspace , err := client . Workspace ( ctx , workspaceID )
require . NoError ( t , err , "unexpected error fetching workspace" )
require . Equal ( t , workspace . LatestBuild . Transition , codersdk . WorkspaceTransition ( from ), "expected workspace state: %s got: %s" , from , workspace . LatestBuild . Transition )
template , err := client . Template ( ctx , workspace . TemplateID )
require . NoError ( t , err , "fetch workspace template" )
build , err := client . CreateWorkspaceBuild ( ctx , workspace . ID , codersdk . CreateWorkspaceBuildRequest {
TemplateVersionID : template . ActiveVersionID ,
Transition : codersdk . WorkspaceTransition ( to ),
})
require . NoError ( t , err , "unexpected error transitioning workspace to %s" , to )
_ = AwaitWorkspaceBuildJob ( t , client , build . ID )
updated := MustWorkspace ( t , client , workspace . ID )
require . Equal ( t , codersdk . WorkspaceTransition ( to ), updated . LatestBuild . Transition , "expected workspace to be in state %s but got %s" , to , updated . LatestBuild . Transition )
return updated
}
// MustWorkspace is a convenience method for fetching a workspace that should exist.
func MustWorkspace ( t * testing . T , client * codersdk . Client , workspaceID uuid . UUID ) codersdk . Workspace {
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-02-27 10:18:19 -06:00
// RequestGitAuthCallback makes a request with the proper OAuth2 state cookie
// to the git auth callback endpoint.
func RequestGitAuthCallback ( t * testing . T , providerID string , client * codersdk . Client ) * http . Response {
client . HTTPClient . CheckRedirect = func ( req * http . Request , via [] * http . Request ) error {
return http . ErrUseLastResponse
}
state := "somestate"
oauthURL , err := client . URL . Parse ( fmt . Sprintf ( "/gitauth/%s/callback?code=asd&state=%s" , providerID , state ))
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 (),
})
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
func NewGoogleInstanceIdentity ( t * testing . T , instanceID string , expired bool ) ( * idtoken . Validator , * metadata . Client ) {
keyID , err := cryptorand . String ( 12 )
require . NoError ( t , err )
claims := jwt . MapClaims {
"google" : map [ string ] interface {}{
"compute_engine" : map [ string ] string {
"instance_id" : instanceID ,
},
},
}
if ! expired {
claims [ "exp" ] = time . Now (). AddDate ( 1 , 0 , 0 ). Unix ()
}
token := jwt . NewWithClaims ( jwt . SigningMethodRS256 , claims )
token . Header [ "kid" ] = keyID
privateKey , err := rsa . GenerateKey ( rand . Reader , 2048 )
require . NoError ( t , err )
signedKey , err := token . SignedString ( privateKey )
require . NoError ( t , err )
// Taken from: https://github.com/googleapis/google-api-go-client/blob/4bb729045d611fa77bdbeb971f6a1204ba23161d/idtoken/validate.go#L57-L75
type jwk struct {
Kid string `json:"kid"`
N string `json:"n"`
E string `json:"e"`
}
type certResponse struct {
Keys [] jwk `json:"keys"`
}
validator , err := idtoken . NewValidator ( context . Background (), option . WithHTTPClient ( & http . Client {
Transport : roundTripper ( func ( r * http . Request ) ( * http . Response , error ) {
data , err := json . Marshal ( certResponse {
Keys : [] jwk {{
Kid : keyID ,
N : base64 . RawURLEncoding . EncodeToString ( privateKey . N . Bytes ()),
E : base64 . RawURLEncoding . EncodeToString ( new ( big . Int ). SetInt64 ( int64 ( privateKey . E )). Bytes ()),
}},
})
require . NoError ( t , err )
return & http . Response {
StatusCode : http . StatusOK ,
2022-03-29 14:59:32 -05:00
Body : io . NopCloser ( bytes . NewReader ( data )),
2022-03-25 13:48:08 -06:00
Header : make ( http . Header ),
}, nil
}),
}))
require . NoError ( t , err )
return validator , metadata . NewClient ( & http . Client {
Transport : roundTripper ( func ( r * http . Request ) ( * http . Response , error ) {
return & http . Response {
StatusCode : http . StatusOK ,
2022-03-29 14:59:32 -05:00
Body : io . NopCloser ( bytes . NewReader ([] byte ( signedKey ))),
2022-03-25 13:48:08 -06:00
Header : make ( http . Header ),
}, nil
}),
})
}
2022-03-28 13:31:03 -06:00
// NewAWSInstanceIdentity returns a metadata client and ID token validator for faking
// instance authentication for AWS.
func NewAWSInstanceIdentity ( t * testing . T , instanceID string ) ( awsidentity . Certificates , * http . Client ) {
privateKey , err := rsa . GenerateKey ( rand . Reader , 2048 )
require . NoError ( t , err )
document := [] byte ( `{"instanceId":"` + instanceID + `"}` )
hashedDocument := sha256 . Sum256 ( document )
signatureRaw , err := rsa . SignPKCS1v15 ( rand . Reader , privateKey , crypto . SHA256 , hashedDocument [:])
require . NoError ( t , err )
signature := make ([] byte , base64 . StdEncoding . EncodedLen ( len ( signatureRaw )))
base64 . StdEncoding . Encode ( signature , signatureRaw )
certificate , err := x509 . CreateCertificate ( rand . Reader , & x509 . Certificate {
SerialNumber : big . NewInt ( 2022 ),
}, & x509 . Certificate {}, & privateKey . PublicKey , privateKey )
require . NoError ( t , err )
certificatePEM := bytes . Buffer {}
err = pem . Encode ( & certificatePEM , & pem . Block {
Type : "CERTIFICATE" ,
Bytes : certificate ,
})
require . NoError ( t , err )
return awsidentity . Certificates {
awsidentity . Other : certificatePEM . String (),
}, & http . Client {
Transport : roundTripper ( func ( r * http . Request ) ( * http . Response , error ) {
// Only handle metadata server requests.
if r . URL . Host != "169.254.169.254" {
return http . DefaultTransport . RoundTrip ( r )
}
switch r . URL . Path {
case "/latest/api/token" :
return & http . Response {
StatusCode : http . StatusOK ,
2022-03-29 14:59:32 -05:00
Body : io . NopCloser ( bytes . NewReader ([] byte ( "faketoken" ))),
2022-03-28 13:31:03 -06:00
Header : make ( http . Header ),
}, nil
case "/latest/dynamic/instance-identity/signature" :
return & http . Response {
StatusCode : http . StatusOK ,
2022-03-29 14:59:32 -05:00
Body : io . NopCloser ( bytes . NewReader ( signature )),
2022-03-28 13:31:03 -06:00
Header : make ( http . Header ),
}, nil
case "/latest/dynamic/instance-identity/document" :
return & http . Response {
StatusCode : http . StatusOK ,
2022-03-29 14:59:32 -05:00
Body : io . NopCloser ( bytes . NewReader ( document )),
2022-03-28 13:31:03 -06:00
Header : make ( http . Header ),
}, nil
default :
panic ( "unhandled route: " + r . URL . Path )
}
}),
}
}
2022-10-17 22:07:11 -05:00
type OIDCConfig struct {
key * rsa . PrivateKey
issuer string
2023-08-08 10:05:12 -05:00
// These are optional
refreshToken string
oidcTokenExpires func () time . Time
tokenSource func () ( * oauth2 . Token , error )
2022-10-17 22:07:11 -05:00
}
2023-08-08 10:05:12 -05:00
func WithRefreshToken ( token string ) func ( cfg * OIDCConfig ) {
return func ( cfg * OIDCConfig ) {
cfg . refreshToken = token
}
}
func WithTokenExpires ( expFunc func () time . Time ) func ( cfg * OIDCConfig ) {
return func ( cfg * OIDCConfig ) {
cfg . oidcTokenExpires = expFunc
}
}
func WithTokenSource ( src func () ( * oauth2 . Token , error )) func ( cfg * OIDCConfig ) {
return func ( cfg * OIDCConfig ) {
cfg . tokenSource = src
}
}
func NewOIDCConfig ( t * testing . T , issuer string , opts ... func ( cfg * OIDCConfig )) * OIDCConfig {
2022-10-17 22:07:11 -05:00
t . Helper ()
block , _ := pem . Decode ([] byte ( testRSAPrivateKey ))
pkey , err := x509 . ParsePKCS1PrivateKey ( block . Bytes )
require . NoError ( t , err )
if issuer == "" {
issuer = "https://coder.com"
}
2023-08-08 10:05:12 -05:00
cfg := & OIDCConfig {
2022-10-17 22:07:11 -05:00
key : pkey ,
issuer : issuer ,
}
2023-08-08 10:05:12 -05:00
for _ , opt := range opts {
opt ( cfg )
}
return cfg
2022-10-17 22:07:11 -05:00
}
func ( * OIDCConfig ) AuthCodeURL ( state string , _ ... oauth2 . AuthCodeOption ) string {
return "/?state=" + url . QueryEscape ( state )
}
2023-08-08 10:05:12 -05:00
type tokenSource struct {
src func () ( * oauth2 . Token , error )
2022-10-17 22:07:11 -05:00
}
2023-08-08 10:05:12 -05:00
func ( s tokenSource ) Token () ( * oauth2 . Token , error ) {
return s . src ()
}
func ( cfg * OIDCConfig ) TokenSource ( context . Context , * oauth2 . Token ) oauth2 . TokenSource {
if cfg . tokenSource == nil {
return nil
}
return tokenSource {
src : cfg . tokenSource ,
}
}
func ( cfg * OIDCConfig ) Exchange ( _ context . Context , code string , _ ... oauth2 . AuthCodeOption ) ( * oauth2 . Token , error ) {
2022-10-17 22:07:11 -05:00
token , err := base64 . StdEncoding . DecodeString ( code )
if err != nil {
return nil , xerrors . Errorf ( "decode code: %w" , err )
}
2023-08-08 10:05:12 -05:00
var exp time . Time
if cfg . oidcTokenExpires != nil {
exp = cfg . oidcTokenExpires ()
}
2022-10-17 22:07:11 -05:00
return ( & oauth2 . Token {
2023-08-08 10:05:12 -05:00
AccessToken : "token" ,
RefreshToken : cfg . refreshToken ,
Expiry : exp ,
2022-10-17 22:07:11 -05:00
}). WithExtra ( map [ string ] interface {}{
"id_token" : string ( token ),
}), nil
}
2023-08-08 10:05:12 -05:00
func ( cfg * OIDCConfig ) EncodeClaims ( t * testing . T , claims jwt . MapClaims ) string {
2022-10-17 22:07:11 -05:00
t . Helper ()
if _ , ok := claims [ "exp" ]; ! ok {
claims [ "exp" ] = time . Now (). Add ( time . Hour ). UnixMilli ()
}
if _ , ok := claims [ "iss" ]; ! ok {
2023-08-08 10:05:12 -05:00
claims [ "iss" ] = cfg . issuer
2022-10-17 22:07:11 -05:00
}
if _ , ok := claims [ "sub" ]; ! ok {
claims [ "sub" ] = "testme"
}
2023-08-08 10:05:12 -05:00
signed , err := jwt . NewWithClaims ( jwt . SigningMethodRS256 , claims ). SignedString ( cfg . key )
2022-10-17 22:07:11 -05:00
require . NoError ( t , err )
return base64 . StdEncoding . EncodeToString ([] byte ( signed ))
}
2023-08-08 10:05:12 -05:00
func ( cfg * OIDCConfig ) OIDCConfig ( t * testing . T , userInfoClaims jwt . MapClaims , opts ... func ( cfg * coderd . OIDCConfig )) * coderd . OIDCConfig {
2023-01-16 16:06:39 -06:00
// By default, the provider can be empty.
// This means it won't support any endpoints!
provider := & oidc . Provider {}
if userInfoClaims != nil {
resp , err := json . Marshal ( userInfoClaims )
require . NoError ( t , err )
srv := httptest . NewServer ( http . HandlerFunc ( func ( w http . ResponseWriter , r * http . Request ) {
w . WriteHeader ( http . StatusOK )
_ , _ = w . Write ( resp )
}))
t . Cleanup ( srv . Close )
cfg := & oidc . ProviderConfig {
UserInfoURL : srv . URL ,
}
provider = cfg . NewProvider ( context . Background ())
}
2023-08-08 10:05:12 -05:00
newCFG := & coderd . OIDCConfig {
OAuth2Config : cfg ,
Verifier : oidc . NewVerifier ( cfg . issuer , & oidc . StaticKeySet {
PublicKeys : [] crypto . PublicKey { cfg . key . Public ()},
2022-10-17 22:07:11 -05:00
}, & oidc . Config {
SkipClientIDCheck : true ,
}),
2023-01-16 16:06:39 -06:00
Provider : provider ,
2023-01-04 22:16:31 +01:00
UsernameField : "preferred_username" ,
2023-03-30 09:36:57 +01:00
EmailField : "email" ,
AuthURLParams : map [ string ] string { "access_type" : "offline" },
2023-03-09 23:31:38 -06:00
GroupField : "groups" ,
2022-10-17 22:07:11 -05:00
}
2023-03-09 23:31:38 -06:00
for _ , opt := range opts {
2023-08-08 10:05:12 -05:00
opt ( newCFG )
2023-03-09 23:31:38 -06:00
}
2023-08-08 10:05:12 -05:00
return newCFG
2022-10-17 22:07:11 -05:00
}
2022-04-19 08:48:13 -05:00
// NewAzureInstanceIdentity returns a metadata client and ID token validator for faking
// instance authentication for Azure.
func NewAzureInstanceIdentity ( t * testing . T , instanceID string ) ( x509 . VerifyOptions , * http . Client ) {
privateKey , err := rsa . GenerateKey ( rand . Reader , 2048 )
require . NoError ( t , err )
rawCertificate , err := x509 . CreateCertificate ( rand . Reader , & x509 . Certificate {
SerialNumber : big . NewInt ( 2022 ),
NotAfter : time . Now (). AddDate ( 1 , 0 , 0 ),
Subject : pkix . Name {
CommonName : "metadata.azure.com" ,
},
}, & x509 . Certificate {}, & privateKey . PublicKey , privateKey )
require . NoError ( t , err )
certificate , err := x509 . ParseCertificate ( rawCertificate )
require . NoError ( t , err )
signed , err := pkcs7 . NewSignedData ([] byte ( `{"vmId":"` + instanceID + `"}` ))
require . NoError ( t , err )
err = signed . AddSigner ( certificate , privateKey , pkcs7 . SignerInfoConfig {})
require . NoError ( t , err )
signatureRaw , err := signed . Finish ()
require . NoError ( t , err )
signature := make ([] byte , base64 . StdEncoding . EncodedLen ( len ( signatureRaw )))
base64 . StdEncoding . Encode ( signature , signatureRaw )
2023-01-29 15:47:24 -06:00
payload , err := json . Marshal ( agentsdk . AzureInstanceIdentityToken {
2022-04-19 08:48:13 -05:00
Signature : string ( signature ),
Encoding : "pkcs7" ,
})
require . NoError ( t , err )
certPool := x509 . NewCertPool ()
certPool . AddCert ( certificate )
return x509 . VerifyOptions {
Intermediates : certPool ,
Roots : certPool ,
}, & http . Client {
Transport : roundTripper ( func ( r * http . Request ) ( * http . Response , error ) {
// Only handle metadata server requests.
if r . URL . Host != "169.254.169.254" {
return http . DefaultTransport . RoundTrip ( r )
}
switch r . URL . Path {
case "/metadata/attested/document" :
return & http . Response {
StatusCode : http . StatusOK ,
Body : io . NopCloser ( bytes . NewReader ( payload )),
Header : make ( http . Header ),
}, nil
default :
panic ( "unhandled route: " + r . URL . Path )
}
}),
}
}
2023-04-06 11:53:02 -05:00
func randomUsername ( t testing . TB ) string {
suffix , err := cryptorand . String ( 3 )
require . NoError ( t , err )
2023-04-20 21:40:36 +03:00
suffix = "-" + suffix
n := strings . ReplaceAll ( namesgenerator . GetRandomName ( 10 ), "_" , "-" ) + suffix
if len ( n ) > 32 {
n = n [: 32 - len ( suffix )] + suffix
}
return n
2022-01-20 07:46:51 -06:00
}
2022-03-25 13:48:08 -06:00
// 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.
func SDKError ( t * testing . T , err error ) * codersdk . Error {
var cerr * codersdk . Error
require . True ( t , errors . As ( err , & cerr ))
return cerr
}
2022-10-17 22:07:11 -05:00
const testRSAPrivateKey = `-----BEGIN RSA PRIVATE KEY-----
MIICXQIBAAKBgQDLets8+7M+iAQAqN/5BVyCIjhTQ4cmXulL+gm3v0oGMWzLupUS
v8KPA+Tp7dgC/DZPfMLaNH1obBBhJ9DhS6RdS3AS3kzeFrdu8zFHLWF53DUBhS92
5dCAEuJpDnNizdEhxTfoHrhuCmz8l2nt1pe5eUK2XWgd08Uc93h5ij098wIDAQAB
AoGAHLaZeWGLSaen6O/rqxg2laZ+jEFbMO7zvOTruiIkL/uJfrY1kw+8RLIn+1q0
wLcWcuEIHgKKL9IP/aXAtAoYh1FBvRPLkovF1NZB0Je/+CSGka6wvc3TGdvppZJe
rKNcUvuOYLxkmLy4g9zuY5qrxFyhtIn2qZzXEtLaVOHzPQECQQDvN0mSajpU7dTB
w4jwx7IRXGSSx65c+AsHSc1Rj++9qtPC6WsFgAfFN2CEmqhMbEUVGPv/aPjdyWk9
pyLE9xR/AkEA2cGwyIunijE5v2rlZAD7C4vRgdcMyCf3uuPcgzFtsR6ZhyQSgLZ8
YRPuvwm4cdPJMmO3YwBfxT6XGuSc2k8MjQJBAI0+b8prvpV2+DCQa8L/pjxp+VhR
Xrq2GozrHrgR7NRokTB88hwFRJFF6U9iogy9wOx8HA7qxEbwLZuhm/4AhbECQC2a
d8h4Ht09E+f3nhTEc87mODkl7WJZpHL6V2sORfeq/eIkds+H6CJ4hy5w/bSw8tjf
sz9Di8sGIaUbLZI2rd0CQQCzlVwEtRtoNCyMJTTrkgUuNufLP19RZ5FpyXxBO5/u
QastnN77KfUwdj3SJt44U/uh1jAIv4oSLBr8HYUkbnI8
-----END RSA PRIVATE KEY-----`
2022-11-08 11:59:39 -05:00
2023-05-08 08:59:01 -05:00
func DeploymentValues ( t testing . TB ) * codersdk . DeploymentValues {
2023-03-07 15:10:01 -06:00
var cfg codersdk . DeploymentValues
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 )
2023-03-07 15:10:01 -06:00
return & cfg
2022-11-08 11:59:39 -05:00
}