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"
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"
2023-01-25 21:35:53 +00:00
"os"
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"
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"
2022-06-24 10:25:01 -05:00
"github.com/spf13/afero"
2022-11-08 11:59:39 -05:00
"github.com/spf13/pflag"
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"
2022-01-20 07:46:51 -06:00
"cdr.dev/slog/sloggers/slogtest"
2022-11-08 11:59:39 -05:00
"github.com/coder/coder/cli/config"
"github.com/coder/coder/cli/deployment"
2022-01-20 07:46:51 -06:00
"github.com/coder/coder/coderd"
2022-09-08 21:16:16 -05:00
"github.com/coder/coder/coderd/audit"
2022-05-11 23:03:02 +01:00
"github.com/coder/coder/coderd/autobuild/executor"
2022-03-28 13:31:03 -06:00
"github.com/coder/coder/coderd/awsidentity"
2022-03-25 16:07:45 -05:00
"github.com/coder/coder/coderd/database"
2022-10-10 15:37:06 -05:00
"github.com/coder/coder/coderd/database/dbtestutil"
2022-10-24 19:46:24 -05:00
"github.com/coder/coder/coderd/gitauth"
2022-04-05 19:18:26 -05:00
"github.com/coder/coder/coderd/gitsshkey"
2022-10-15 04:25:11 +10:00
"github.com/coder/coder/coderd/httpapi"
2022-10-23 13:21:49 -05:00
"github.com/coder/coder/coderd/httpmw"
2022-06-24 10:25:01 -05:00
"github.com/coder/coder/coderd/rbac"
"github.com/coder/coder/coderd/telemetry"
2022-12-01 19:43:28 +02:00
"github.com/coder/coder/coderd/updatecheck"
2022-06-24 10:25:01 -05:00
"github.com/coder/coder/coderd/util/ptr"
2022-01-20 07:46:51 -06:00
"github.com/coder/coder/codersdk"
2023-01-29 15:47:24 -06:00
"github.com/coder/coder/codersdk/agentsdk"
2022-03-25 13:48:08 -06:00
"github.com/coder/coder/cryptorand"
2022-02-04 16:51:54 -06:00
"github.com/coder/coder/provisioner/echo"
2022-02-03 14:34:50 -06:00
"github.com/coder/coder/provisionerd"
2022-11-16 16:34:06 -06:00
provisionerdproto "github.com/coder/coder/provisionerd/proto"
2022-02-03 14:34:50 -06:00
"github.com/coder/coder/provisionersdk"
2022-11-10 16:37:33 -06:00
sdkproto "github.com/coder/coder/provisionersdk/proto"
2022-10-17 08:43:30 -05:00
"github.com/coder/coder/tailnet"
2022-08-01 15:45:05 +03:00
"github.com/coder/coder/testutil"
2022-01-20 07:46:51 -06: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).
AccessURL * url . URL
2022-09-23 08:30:32 +10:00
AppHostname string
2022-04-19 08:48:13 -05:00
AWSCertificates awsidentity . Certificates
2022-05-17 13:43:19 -05:00
Authorizer rbac . Authorizer
2022-04-19 08:48:13 -05:00
AzureCertificates x509 . VerifyOptions
2022-04-23 17:58:57 -05:00
GithubOAuth2Config * coderd . GithubOAuth2Config
2022-10-23 13:21:49 -05:00
RealIPConfig * httpmw . RealIPConfig
2022-07-31 23:05:35 -05:00
OIDCConfig * coderd . OIDCConfig
2022-04-19 08:48:13 -05:00
GoogleTokenValidator * idtoken . Validator
SSHKeygenAlgorithm gitsshkey . Algorithm
2022-05-13 17:14:24 +01:00
AutobuildTicker <- chan time . Time
2022-05-30 20:23:36 +01:00
AutobuildStats chan <- executor . Stats
2022-09-08 21:16:16 -05:00
Auditor audit . Auditor
2022-10-17 08:43:30 -05:00
TLSCertificates [] tls . Certificate
2022-10-24 19:46:24 -05:00
GitAuthConfigs [] * gitauth . Config
2022-11-16 17:09:49 -06:00
TrialGenerator func ( context . Context , string ) error
2022-05-19 15:47:45 -07:00
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
2022-10-21 17:08:23 -05:00
DeploymentConfig * codersdk . DeploymentConfig
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
Pubsub database . Pubsub
2022-12-19 18:43:46 +01:00
SwaggerEndpoint bool
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.
2022-05-18 15:49:46 -05:00
func New ( t * testing . T , 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.
func newWithCloser ( t * testing . T , 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
}
2022-12-16 04:43:00 +10:00
func NewOptions ( t * testing . T , options * Options ) ( func ( http . Handler ), context . CancelFunc , * url . URL , * coderd . Options ) {
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 )
})
}
2022-10-17 08:43:30 -05:00
if options . Database == nil {
options . Database , options . Pubsub = dbtestutil . NewDB ( t )
}
2023-01-25 21:35:53 +00:00
// TODO: remove this once we're ready to enable authz querier by default.
if strings . Contains ( os . Getenv ( "CODER_EXPERIMENTS_TEST" ), "authz_querier" ) {
panic ( "Coming soon!" )
// if options.Authorizer != nil {
// options.Authorizer = &RecordingAuthorizer{}
// }
// options.Database = authzquery.NewAuthzQuerier(options.Database, options.Authorizer)
}
2022-11-08 11:59:39 -05:00
if options . DeploymentConfig == nil {
options . DeploymentConfig = DeploymentConfig ( t )
}
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
}
2022-04-18 17:40:25 -05:00
ctx , cancelFunc := context . WithCancel ( context . Background ())
2022-05-11 23:03:02 +01:00
lifecycleExecutor := executor . New (
ctx ,
2022-10-17 08:43:30 -05:00
options . Database ,
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 ()
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 ()
defer mutex . RUnlock ()
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
}
2022-09-14 20:21:53 -05:00
stunAddr , stunCleanup := stuntest . ServeWithPacketListener ( t , nettype . Std {})
t . Cleanup ( stunCleanup )
2022-10-17 08:43:30 -05:00
derpServer := derp . NewServer ( key . NewNode (), tailnet . Logger ( slogtest . Make ( t , nil ). Named ( "derp" )))
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 )
}
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 ,
Logger : slogtest . Make ( t , nil ). Leveled ( slog . LevelDebug ),
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
2022-10-17 08:43:30 -05:00
Auditor : options . Auditor ,
AWSCertificates : options . AWSCertificates ,
AzureCertificates : options . AzureCertificates ,
GithubOAuth2Config : options . GithubOAuth2Config ,
2022-10-23 13:21:49 -05:00
RealIPConfig : options . RealIPConfig ,
2022-10-17 08:43:30 -05:00
OIDCConfig : options . OIDCConfig ,
GoogleTokenValidator : options . GoogleTokenValidator ,
SSHKeygenAlgorithm : options . SSHKeygenAlgorithm ,
DERPServer : derpServer ,
APIRateLimit : options . APIRateLimit ,
2023-01-05 12:05:20 -06:00
LoginRateLimit : options . LoginRateLimit ,
FilesRateLimit : options . FilesRateLimit ,
2022-10-17 08:43:30 -05:00
Authorizer : options . Authorizer ,
Telemetry : telemetry . NewNoop (),
TLSCertificates : options . TLSCertificates ,
2022-11-16 17:09:49 -06:00
TrialGenerator : options . TrialGenerator ,
2022-10-17 08:43:30 -05:00
DERPMap : & tailcfg . DERPMap {
Regions : map [ int ] * tailcfg . DERPRegion {
1 : {
EmbeddedRelay : true ,
RegionID : 1 ,
RegionCode : "coder" ,
RegionName : "Coder" ,
Nodes : [] * tailcfg . DERPNode {{
Name : "1a" ,
RegionID : 1 ,
IPv4 : "127.0.0.1" ,
DERPPort : derpPort ,
STUNPort : stunAddr . Port ,
InsecureForTests : true ,
ForceHTTP : options . TLSCertificates == nil ,
}},
},
2022-08-31 20:09:44 -05:00
},
},
2022-10-17 08:43:30 -05:00
MetricsCacheRefreshInterval : options . MetricsCacheRefreshInterval ,
AgentStatsRefreshInterval : options . AgentStatsRefreshInterval ,
2022-10-21 17:08:23 -05:00
DeploymentConfig : options . DeploymentConfig ,
2022-12-01 19:43:28 +02:00
UpdateCheckOptions : options . UpdateCheckOptions ,
2022-12-19 18:43:46 +01:00
SwaggerEndpoint : options . SwaggerEndpoint ,
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.
func NewWithAPI ( t * testing . T , options * Options ) ( * codersdk . Client , io . Closer , * coderd . API ) {
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.
2022-05-25 22:14:08 -05:00
func NewProvisionerDaemon ( t * testing . T , coderAPI * coderd . API ) io . Closer {
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 ,
Logger : slogtest . Make ( t , nil ). 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 ())
t . Cleanup ( func () {
_ = echoClient . Close ()
_ = echoServer . Close ()
cancelFunc ()
})
fs := afero . NewMemMapFs ()
go func () {
err := echo . Serve ( ctx , fs , & provisionersdk . ServeOptions {
Listener : echoServer ,
})
assert . NoError ( t , err )
}()
closer := provisionerd . New ( func ( ctx context . Context ) ( provisionerdproto . DRPCProvisionerDaemonClient , error ) {
return client . ServeProvisionerDaemon ( ctx , org , [] codersdk . ProvisionerType { codersdk . ProvisionerTypeEcho }, 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" ,
Password : "testpass" ,
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.
2022-03-22 13:17:50 -06:00
func CreateFirstUser ( t * testing . T , 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 ) {
2022-06-29 14:17:32 -05:00
return createAnotherUserRetry ( t , client , organizationID , 5 , roles ... )
}
2022-08-09 13:16:53 -05:00
func createAnotherUserRetry ( t * testing . T , client * codersdk . Client , organizationID uuid . UUID , retries int , roles ... string ) ( * 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" ,
2022-03-07 11:40:54 -06:00
Username : randomUsername (),
Password : "testpass" ,
2022-04-01 14:42:36 -05:00
OrganizationID : organizationID ,
2022-03-07 11:40:54 -06:00
}
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 --
return createAnotherUserRetry ( t , client , organizationID , retries , roles ... )
}
}
2022-03-07 11:40:54 -06:00
require . NoError ( t , err )
2022-03-22 13:17:50 -06:00
login , err := client . LoginWithPassword ( context . Background (), codersdk . LoginWithPasswordRequest {
2022-03-07 11:40:54 -06:00
Email : req . Email ,
Password : req . Password ,
})
require . NoError ( t , err )
other := codersdk . New ( client . URL )
2022-11-09 15:31:24 +02:00
other . SetSessionToken ( login . SessionToken )
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.
2022-04-06 12:42:40 -05:00
func CreateTemplateVersion ( t * testing . T , client * codersdk . Client , organizationID uuid . UUID , res * echo . Responses ) 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 )
2022-04-06 12:42:40 -05:00
templateVersion , err := client . CreateTemplateVersion ( context . Background (), organizationID , 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 ,
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 ,
) 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
}
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 {
2022-05-16 15:56:11 -05:00
Name : randomUsername (),
Description : randomUsername (),
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
}
// AwaitWorkspaceAgents waits for all resources with agents to be connected.
2022-10-03 17:01:13 -04:00
func AwaitWorkspaceAgents ( t * testing . T , client * codersdk . Client , workspaceID uuid . UUID ) [] codersdk . WorkspaceResource {
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 . 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 {
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 ,
Name : randomUsername (),
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
}
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
}
func NewOIDCConfig ( t * testing . T , issuer string ) * OIDCConfig {
t . Helper ()
block , _ := pem . Decode ([] byte ( testRSAPrivateKey ))
pkey , err := x509 . ParsePKCS1PrivateKey ( block . Bytes )
require . NoError ( t , err )
if issuer == "" {
issuer = "https://coder.com"
}
return & OIDCConfig {
key : pkey ,
issuer : issuer ,
}
}
func ( * OIDCConfig ) AuthCodeURL ( state string , _ ... oauth2 . AuthCodeOption ) string {
return "/?state=" + url . QueryEscape ( state )
}
func ( * OIDCConfig ) TokenSource ( context . Context , * oauth2 . Token ) oauth2 . TokenSource {
return nil
}
func ( * OIDCConfig ) Exchange ( _ context . Context , code string , _ ... oauth2 . AuthCodeOption ) ( * oauth2 . Token , error ) {
token , err := base64 . StdEncoding . DecodeString ( code )
if err != nil {
return nil , xerrors . Errorf ( "decode code: %w" , err )
}
return ( & oauth2 . Token {
AccessToken : "token" ,
}). WithExtra ( map [ string ] interface {}{
"id_token" : string ( token ),
}), nil
}
func ( o * OIDCConfig ) EncodeClaims ( t * testing . T , claims jwt . MapClaims ) string {
t . Helper ()
if _ , ok := claims [ "exp" ]; ! ok {
claims [ "exp" ] = time . Now (). Add ( time . Hour ). UnixMilli ()
}
if _ , ok := claims [ "iss" ]; ! ok {
claims [ "iss" ] = o . issuer
}
if _ , ok := claims [ "sub" ]; ! ok {
claims [ "sub" ] = "testme"
}
signed , err := jwt . NewWithClaims ( jwt . SigningMethodRS256 , claims ). SignedString ( o . key )
require . NoError ( t , err )
return base64 . StdEncoding . EncodeToString ([] byte ( signed ))
}
2023-01-16 16:06:39 -06:00
func ( o * OIDCConfig ) OIDCConfig ( t * testing . T , userInfoClaims jwt . MapClaims ) * coderd . OIDCConfig {
// 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 ())
}
2022-10-17 22:07:11 -05:00
return & coderd . OIDCConfig {
OAuth2Config : o ,
Verifier : oidc . NewVerifier ( o . issuer , & oidc . StaticKeySet {
PublicKeys : [] crypto . PublicKey { o . key . Public ()},
}, & 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" ,
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 )
}
}),
}
}
2022-02-05 18:24:51 -06:00
func randomUsername () string {
2022-07-20 18:03:04 +03:00
return strings . ReplaceAll ( namesgenerator . GetRandomName ( 10 ), "_" , "-" )
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
func DeploymentConfig ( t * testing . T ) * codersdk . DeploymentConfig {
vip := deployment . NewViper ()
fs := pflag . NewFlagSet ( randomUsername (), pflag . ContinueOnError )
fs . String ( config . FlagName , randomUsername (), randomUsername ())
cfg , err := deployment . Config ( fs , vip )
require . NoError ( t , err )
return cfg
}