2022-09-19 23:11:01 -05:00
package coderd_test
import (
2023-09-07 15:49:49 +01:00
"bytes"
2022-09-19 23:11:01 -05:00
"context"
2024-10-24 16:26:16 -04:00
"encoding/json"
2024-08-26 13:05:03 -05:00
"fmt"
2024-11-20 17:04:33 +10:00
"io"
"net"
2024-03-25 20:01:42 +01:00
"net/http"
2024-08-30 18:43:51 +10:00
"net/http/httptest"
2024-11-20 17:04:33 +10:00
"net/url"
2022-09-19 23:11:01 -05:00
"reflect"
2023-09-07 15:49:49 +01:00
"strings"
2024-11-20 17:04:33 +10:00
"sync"
2022-09-19 23:11:01 -05:00
"testing"
"time"
2023-02-15 16:14:37 +00:00
"github.com/google/uuid"
2024-11-20 17:04:33 +10:00
"github.com/moby/moby/pkg/namesgenerator"
2022-09-19 23:11:01 -05:00
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"go.uber.org/goleak"
2024-11-20 17:04:33 +10:00
"cdr.dev/slog"
"cdr.dev/slog/sloggers/slogtest"
"github.com/coder/coder/v2/agent"
"github.com/coder/coder/v2/agent/agenttest"
2024-08-30 18:43:51 +10:00
"github.com/coder/coder/v2/coderd/httpapi"
2025-04-25 11:07:15 +02:00
agplprebuilds "github.com/coder/coder/v2/coderd/prebuilds"
2024-05-15 09:46:35 -05:00
"github.com/coder/coder/v2/coderd/rbac/policy"
2024-11-20 17:04:33 +10:00
"github.com/coder/coder/v2/coderd/util/ptr"
2025-04-25 11:07:15 +02:00
"github.com/coder/coder/v2/enterprise/coderd/prebuilds"
2025-07-22 13:39:26 +10:00
"github.com/coder/coder/v2/provisioner/echo"
"github.com/coder/coder/v2/provisionersdk/proto"
2024-08-30 18:43:51 +10:00
"github.com/coder/coder/v2/tailnet/tailnettest"
2024-03-21 16:53:41 -05:00
2025-04-25 11:07:15 +02:00
"github.com/coder/retry"
"github.com/coder/serpent"
2023-08-18 13:55:43 -05:00
agplaudit "github.com/coder/coder/v2/coderd/audit"
"github.com/coder/coder/v2/coderd/coderdtest"
"github.com/coder/coder/v2/coderd/database"
2023-08-31 13:32:28 -05:00
"github.com/coder/coder/v2/coderd/database/dbauthz"
2024-11-20 17:04:33 +10:00
"github.com/coder/coder/v2/coderd/database/dbfake"
2023-09-07 15:49:49 +01:00
"github.com/coder/coder/v2/coderd/database/dbtestutil"
2023-09-01 19:50:12 +03:00
"github.com/coder/coder/v2/coderd/database/dbtime"
2023-08-31 13:32:28 -05:00
"github.com/coder/coder/v2/coderd/rbac"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/codersdk"
2024-03-26 12:44:31 -05:00
"github.com/coder/coder/v2/codersdk/workspacesdk"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/enterprise/audit"
"github.com/coder/coder/v2/enterprise/coderd"
"github.com/coder/coder/v2/enterprise/coderd/coderdenttest"
"github.com/coder/coder/v2/enterprise/coderd/license"
2023-09-07 15:49:49 +01:00
"github.com/coder/coder/v2/enterprise/dbcrypt"
2024-03-21 16:53:41 -05:00
"github.com/coder/coder/v2/enterprise/replicasync"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/testutil"
2022-09-19 23:11:01 -05:00
)
func TestMain ( m * testing . M ) {
2025-01-08 15:38:37 +00:00
goleak . VerifyTestMain ( m , testutil . GoleakOptions ... )
2022-09-19 23:11:01 -05:00
}
func TestEntitlements ( t * testing . T ) {
t . Parallel ()
t . Run ( "NoLicense" , func ( t * testing . T ) {
t . Parallel ()
2024-08-26 13:05:03 -05:00
adminClient , _ , api , adminUser := coderdenttest . NewWithAPI ( t , & coderdenttest . Options {
2023-07-12 13:35:29 +04:00
DontAddLicense : true ,
})
2023-11-08 14:54:48 +00:00
anotherClient , _ := coderdtest . CreateAnotherUser ( t , adminClient , adminUser . OrganizationID )
res , err := anotherClient . Entitlements ( context . Background ())
2022-09-19 23:11:01 -05:00
require . NoError ( t , err )
require . False ( t , res . HasLicense )
require . Empty ( t , res . Warnings )
2024-08-26 13:05:03 -05:00
// Ensure the entitlements are the same reference
require . Equal ( t , fmt . Sprintf ( "%p" , api . Entitlements ), fmt . Sprintf ( "%p" , api . AGPL . Entitlements ))
2022-09-19 23:11:01 -05:00
})
t . Run ( "FullLicense" , func ( t * testing . T ) {
2024-01-05 08:03:36 +04:00
// PGCoordinator requires a real postgres
if ! dbtestutil . WillUsePostgres () {
t . Skip ( "test only with postgres" )
}
2022-09-19 23:11:01 -05:00
t . Parallel ()
2023-11-08 14:54:48 +00:00
adminClient , _ := coderdenttest . New ( t , & coderdenttest . Options {
2023-07-12 13:35:29 +04:00
AuditLogging : true ,
DontAddLicense : true ,
2022-10-05 13:45:05 -04:00
})
2023-09-07 15:49:49 +01:00
// Enable all features
features := make ( license . Features )
for _ , feature := range codersdk . FeatureNames {
features [ feature ] = 1
}
features [ codersdk . FeatureUserLimit ] = 100
2023-11-08 14:54:48 +00:00
coderdenttest . AddLicense ( t , adminClient , coderdenttest . LicenseOptions {
2023-09-07 15:49:49 +01:00
Features : features ,
GraceAt : time . Now (). Add ( 59 * 24 * time . Hour ),
2022-09-19 23:11:01 -05:00
})
2023-11-08 14:54:48 +00:00
res , err := adminClient . Entitlements ( context . Background ()) //nolint:gocritic // adding another user would put us over user limit
2022-09-19 23:11:01 -05:00
require . NoError ( t , err )
assert . True ( t , res . HasLicense )
ul := res . Features [ codersdk . FeatureUserLimit ]
assert . Equal ( t , codersdk . EntitlementEntitled , ul . Entitlement )
2023-09-07 15:49:49 +01:00
if assert . NotNil ( t , ul . Limit ) {
assert . Equal ( t , int64 ( 100 ), * ul . Limit )
}
if assert . NotNil ( t , ul . Actual ) {
assert . Equal ( t , int64 ( 1 ), * ul . Actual )
}
2022-09-19 23:11:01 -05:00
assert . True ( t , ul . Enabled )
al := res . Features [ codersdk . FeatureAuditLog ]
assert . Equal ( t , codersdk . EntitlementEntitled , al . Entitlement )
assert . True ( t , al . Enabled )
assert . Nil ( t , al . Limit )
assert . Nil ( t , al . Actual )
assert . Empty ( t , res . Warnings )
})
t . Run ( "FullLicenseToNone" , func ( t * testing . T ) {
t . Parallel ()
2023-11-08 14:54:48 +00:00
adminClient , adminUser := coderdenttest . New ( t , & coderdenttest . Options {
2023-07-12 13:35:29 +04:00
AuditLogging : true ,
DontAddLicense : true ,
2022-10-05 13:45:05 -04:00
})
2023-11-08 14:54:48 +00:00
anotherClient , _ := coderdtest . CreateAnotherUser ( t , adminClient , adminUser . OrganizationID )
license := coderdenttest . AddLicense ( t , adminClient , coderdenttest . LicenseOptions {
2023-01-17 17:04:29 -06:00
Features : license . Features {
codersdk . FeatureUserLimit : 100 ,
codersdk . FeatureAuditLog : 1 ,
},
2022-09-19 23:11:01 -05:00
})
2023-11-08 14:54:48 +00:00
res , err := anotherClient . Entitlements ( context . Background ())
2022-09-19 23:11:01 -05:00
require . NoError ( t , err )
assert . True ( t , res . HasLicense )
al := res . Features [ codersdk . FeatureAuditLog ]
assert . Equal ( t , codersdk . EntitlementEntitled , al . Entitlement )
assert . True ( t , al . Enabled )
2023-11-08 14:54:48 +00:00
err = adminClient . DeleteLicense ( context . Background (), license . ID )
2022-09-19 23:11:01 -05:00
require . NoError ( t , err )
2023-11-08 14:54:48 +00:00
res , err = anotherClient . Entitlements ( context . Background ())
2022-09-19 23:11:01 -05:00
require . NoError ( t , err )
assert . False ( t , res . HasLicense )
al = res . Features [ codersdk . FeatureAuditLog ]
assert . Equal ( t , codersdk . EntitlementNotEntitled , al . Entitlement )
2022-10-17 08:43:30 -05:00
assert . False ( t , al . Enabled )
2022-09-19 23:11:01 -05:00
})
t . Run ( "Pubsub" , func ( t * testing . T ) {
t . Parallel ()
2023-11-08 14:54:48 +00:00
adminClient , _ , api , adminUser := coderdenttest . NewWithAPI ( t , & coderdenttest . Options { DontAddLicense : true })
anotherClient , _ := coderdtest . CreateAnotherUser ( t , adminClient , adminUser . OrganizationID )
entitlements , err := anotherClient . Entitlements ( context . Background ())
2022-09-19 23:11:01 -05:00
require . NoError ( t , err )
require . False ( t , entitlements . HasLicense )
2023-02-14 08:27:06 -06:00
//nolint:gocritic // unit test
2023-02-15 16:14:37 +00:00
ctx := testDBAuthzRole ( context . Background ())
2023-02-14 08:27:06 -06:00
_ , err = api . Database . InsertLicense ( ctx , database . InsertLicenseParams {
2023-09-01 19:50:12 +03:00
UploadedAt : dbtime . Now (),
Exp : dbtime . Now (). AddDate ( 1 , 0 , 0 ),
2022-09-19 23:11:01 -05:00
JWT : coderdenttest . GenerateLicense ( t , coderdenttest . LicenseOptions {
2023-01-17 17:04:29 -06:00
Features : license . Features {
codersdk . FeatureAuditLog : 1 ,
},
2022-09-19 23:11:01 -05:00
}),
})
require . NoError ( t , err )
err = api . Pubsub . Publish ( coderd . PubsubEventLicenses , [] byte {})
require . NoError ( t , err )
require . Eventually ( t , func () bool {
2023-11-08 14:54:48 +00:00
entitlements , err := anotherClient . Entitlements ( context . Background ())
2022-09-19 23:11:01 -05:00
assert . NoError ( t , err )
return entitlements . HasLicense
}, testutil . WaitShort , testutil . IntervalFast )
})
t . Run ( "Resync" , func ( t * testing . T ) {
t . Parallel ()
2023-11-08 14:54:48 +00:00
adminClient , _ , api , adminUser := coderdenttest . NewWithAPI ( t , & coderdenttest . Options {
2022-09-19 23:11:01 -05:00
EntitlementsUpdateInterval : 25 * time . Millisecond ,
2023-07-12 13:35:29 +04:00
DontAddLicense : true ,
2022-09-19 23:11:01 -05:00
})
2023-11-08 14:54:48 +00:00
anotherClient , _ := coderdtest . CreateAnotherUser ( t , adminClient , adminUser . OrganizationID )
entitlements , err := anotherClient . Entitlements ( context . Background ())
2022-09-19 23:11:01 -05:00
require . NoError ( t , err )
require . False ( t , entitlements . HasLicense )
// Valid
2023-02-14 08:27:06 -06:00
ctx := context . Background ()
//nolint:gocritic // unit test
2023-02-15 16:14:37 +00:00
_ , err = api . Database . InsertLicense ( testDBAuthzRole ( ctx ), database . InsertLicenseParams {
2023-09-01 19:50:12 +03:00
UploadedAt : dbtime . Now (),
Exp : dbtime . Now (). AddDate ( 1 , 0 , 0 ),
2022-09-19 23:11:01 -05:00
JWT : coderdenttest . GenerateLicense ( t , coderdenttest . LicenseOptions {
2023-01-17 17:04:29 -06:00
Features : license . Features {
codersdk . FeatureAuditLog : 1 ,
},
2022-09-19 23:11:01 -05:00
}),
})
require . NoError ( t , err )
// Expired
2023-02-14 08:27:06 -06:00
//nolint:gocritic // unit test
2023-02-15 16:14:37 +00:00
_ , err = api . Database . InsertLicense ( testDBAuthzRole ( ctx ), database . InsertLicenseParams {
2023-09-01 19:50:12 +03:00
UploadedAt : dbtime . Now (),
Exp : dbtime . Now (). AddDate ( - 1 , 0 , 0 ),
2022-09-19 23:11:01 -05:00
JWT : coderdenttest . GenerateLicense ( t , coderdenttest . LicenseOptions {
2023-09-01 19:50:12 +03:00
ExpiresAt : dbtime . Now (). AddDate ( - 1 , 0 , 0 ),
2022-09-19 23:11:01 -05:00
}),
})
require . NoError ( t , err )
// Invalid
2023-02-14 08:27:06 -06:00
//nolint:gocritic // unit test
2023-02-15 16:14:37 +00:00
_ , err = api . Database . InsertLicense ( testDBAuthzRole ( ctx ), database . InsertLicenseParams {
2023-09-01 19:50:12 +03:00
UploadedAt : dbtime . Now (),
Exp : dbtime . Now (). AddDate ( 1 , 0 , 0 ),
2022-09-19 23:11:01 -05:00
JWT : "invalid" ,
})
require . NoError ( t , err )
require . Eventually ( t , func () bool {
2023-11-08 14:54:48 +00:00
entitlements , err := anotherClient . Entitlements ( context . Background ())
2022-09-19 23:11:01 -05:00
assert . NoError ( t , err )
return entitlements . HasLicense
}, testutil . WaitShort , testutil . IntervalFast )
})
}
2024-03-25 20:01:42 +01:00
func TestEntitlements_HeaderWarnings ( t * testing . T ) {
t . Parallel ()
t . Run ( "ExistForAdmin" , func ( t * testing . T ) {
t . Parallel ()
adminClient , _ := coderdenttest . New ( t , & coderdenttest . Options {
AuditLogging : true ,
LicenseOptions : & coderdenttest . LicenseOptions {
AllFeatures : false ,
},
})
//nolint:gocritic // This isn't actually bypassing any RBAC checks
res , err := adminClient . Request ( context . Background (), http . MethodGet , "/api/v2/users/me" , nil )
require . NoError ( t , err )
defer res . Body . Close ()
require . Equal ( t , http . StatusOK , res . StatusCode )
require . NotEmpty ( t , res . Header . Values ( codersdk . EntitlementsWarningHeader ))
})
t . Run ( "NoneForNormalUser" , func ( t * testing . T ) {
t . Parallel ()
adminClient , adminUser := coderdenttest . New ( t , & coderdenttest . Options {
AuditLogging : true ,
LicenseOptions : & coderdenttest . LicenseOptions {
AllFeatures : false ,
},
})
anotherClient , _ := coderdtest . CreateAnotherUser ( t , adminClient , adminUser . OrganizationID )
res , err := anotherClient . Request ( context . Background (), http . MethodGet , "/api/v2/users/me" , nil )
require . NoError ( t , err )
defer res . Body . Close ()
require . Equal ( t , http . StatusOK , res . StatusCode )
require . Empty ( t , res . Header . Values ( codersdk . EntitlementsWarningHeader ))
})
}
2025-04-25 11:07:15 +02:00
func TestEntitlements_Prebuilds ( t * testing . T ) {
t . Parallel ()
cases := [] struct {
2025-06-26 15:54:52 +02:00
name string
featureEnabled bool
expectedEnabled bool
2025-04-25 11:07:15 +02:00
}{
{
2025-06-26 15:54:52 +02:00
name : "Feature enabled" ,
featureEnabled : true ,
expectedEnabled : true ,
2025-04-25 11:07:15 +02:00
},
{
2025-06-26 15:54:52 +02:00
name : "Feature disabled" ,
featureEnabled : false ,
expectedEnabled : false ,
2025-04-25 11:07:15 +02:00
},
}
for _ , tc := range cases {
t . Run ( tc . name , func ( t * testing . T ) {
t . Parallel ()
var prebuildsEntitled int64
if tc . featureEnabled {
prebuildsEntitled = 1
}
_ , _ , api , _ := coderdenttest . NewWithAPI ( t , & coderdenttest . Options {
Options : & coderdtest . Options {
2025-06-26 15:54:52 +02:00
DeploymentValues : coderdtest . DeploymentValues ( t ),
2025-04-25 11:07:15 +02:00
},
EntitlementsUpdateInterval : time . Second ,
LicenseOptions : & coderdenttest . LicenseOptions {
Features : license . Features {
codersdk . FeatureWorkspacePrebuilds : prebuildsEntitled ,
},
},
})
// The entitlements will need to refresh before the reconciler is set.
require . Eventually ( t , func () bool {
return api . AGPL . PrebuildsReconciler . Load () != nil
}, testutil . WaitSuperLong , testutil . IntervalFast )
reconciler := api . AGPL . PrebuildsReconciler . Load ()
claimer := api . AGPL . PrebuildsClaimer . Load ()
require . NotNil ( t , reconciler )
require . NotNil ( t , claimer )
if tc . expectedEnabled {
require . IsType ( t , & prebuilds . StoreReconciler {}, * reconciler )
2025-04-30 16:26:30 +02:00
require . IsType ( t , & prebuilds . EnterpriseClaimer {}, * claimer )
2025-04-25 11:07:15 +02:00
} else {
require . Equal ( t , & agplprebuilds . DefaultReconciler , reconciler )
require . Equal ( t , & agplprebuilds . DefaultClaimer , claimer )
}
})
}
}
2022-09-19 23:11:01 -05:00
func TestAuditLogging ( t * testing . T ) {
t . Parallel ()
t . Run ( "Enabled" , func ( t * testing . T ) {
t . Parallel ()
2025-07-08 17:16:46 +02:00
db , _ := dbtestutil . NewDB ( t )
2023-07-12 13:35:29 +04:00
_ , _ , api , _ := coderdenttest . NewWithAPI ( t , & coderdenttest . Options {
2022-10-05 13:45:05 -04:00
AuditLogging : true ,
2022-10-19 02:00:45 -05:00
Options : & coderdtest . Options {
2025-07-08 17:16:46 +02:00
Auditor : audit . NewAuditor ( db , audit . DefaultFilter ),
2022-10-19 02:00:45 -05:00
},
2023-07-12 13:35:29 +04:00
LicenseOptions : & coderdenttest . LicenseOptions {
Features : license . Features {
codersdk . FeatureAuditLog : 1 ,
},
2023-01-17 17:04:29 -06:00
},
2022-09-19 23:11:01 -05:00
})
2025-07-08 17:16:46 +02:00
db , _ = dbtestutil . NewDB ( t )
2022-09-19 23:11:01 -05:00
auditor := * api . AGPL . Auditor . Load ()
2025-07-08 17:16:46 +02:00
ea := audit . NewAuditor ( db , audit . DefaultFilter )
2022-09-19 23:11:01 -05:00
t . Logf ( "%T = %T" , auditor , ea )
2022-10-05 13:45:05 -04:00
assert . EqualValues ( t , reflect . ValueOf ( ea ). Type (), reflect . ValueOf ( auditor ). Type ())
2022-09-19 23:11:01 -05:00
})
t . Run ( "Disabled" , func ( t * testing . T ) {
t . Parallel ()
2023-07-12 13:35:29 +04:00
_ , _ , api , _ := coderdenttest . NewWithAPI ( t , & coderdenttest . Options { DontAddLicense : true })
2022-09-19 23:11:01 -05:00
auditor := * api . AGPL . Auditor . Load ()
ea := agplaudit . NewNop ()
t . Logf ( "%T = %T" , auditor , ea )
assert . Equal ( t , reflect . ValueOf ( ea ). Type (), reflect . ValueOf ( auditor ). Type ())
})
2023-03-10 11:04:40 -06:00
// The AGPL code runs with a fake auditor that doesn't represent the real implementation.
// We do a simple test to ensure that basic flows function.
t . Run ( "FullBuild" , func ( t * testing . T ) {
t . Parallel ()
2023-03-23 17:42:20 -05:00
ctx := testutil . Context ( t , testutil . WaitLong )
2023-07-12 13:35:29 +04:00
client , user := coderdenttest . New ( t , & coderdenttest . Options {
2023-03-10 11:04:40 -06:00
Options : & coderdtest . Options {
IncludeProvisionerDaemon : true ,
},
2023-07-12 13:35:29 +04:00
DontAddLicense : true ,
2023-03-10 11:04:40 -06:00
})
2024-02-23 11:04:23 +04:00
r := setupWorkspaceAgent ( t , client , user , 0 )
2024-03-26 12:44:31 -05:00
conn , err := workspacesdk . New ( client ). DialAgent ( ctx , r . sdkAgent . ID , nil ) //nolint:gocritic // RBAC is not the purpose of this test
2023-03-10 11:04:40 -06:00
require . NoError ( t , err )
defer conn . Close ()
connected := conn . AwaitReachable ( ctx )
require . True ( t , connected )
2024-02-23 11:04:23 +04:00
_ = r . agent . Close () // close first so we don't drop error logs from outdated build
build := coderdtest . CreateWorkspaceBuild ( t , client , r . workspace , database . WorkspaceTransitionStop )
2023-10-03 11:02:56 -06:00
coderdtest . AwaitWorkspaceBuildJobCompleted ( t , client , build . ID )
2023-03-10 11:04:40 -06:00
})
2022-09-19 23:11:01 -05:00
}
2023-02-15 16:14:37 +00:00
2023-09-07 15:49:49 +01:00
func TestExternalTokenEncryption ( t * testing . T ) {
t . Parallel ()
t . Run ( "Enabled" , func ( t * testing . T ) {
t . Parallel ()
ctx := testutil . Context ( t , testutil . WaitShort )
db , ps := dbtestutil . NewDB ( t )
ciphers , err := dbcrypt . NewCiphers ( bytes . Repeat ([] byte ( "a" ), 32 ))
require . NoError ( t , err )
client , _ := coderdenttest . New ( t , & coderdenttest . Options {
EntitlementsUpdateInterval : 25 * time . Millisecond ,
ExternalTokenEncryption : ciphers ,
LicenseOptions : & coderdenttest . LicenseOptions {
Features : license . Features {
codersdk . FeatureExternalTokenEncryption : 1 ,
},
},
Options : & coderdtest . Options {
Database : db ,
Pubsub : ps ,
},
})
keys , err := db . GetDBCryptKeys ( ctx )
require . NoError ( t , err )
require . Len ( t , keys , 1 )
require . Equal ( t , ciphers [ 0 ]. HexDigest (), keys [ 0 ]. ActiveKeyDigest . String )
require . Eventually ( t , func () bool {
entitlements , err := client . Entitlements ( context . Background ())
assert . NoError ( t , err )
feature := entitlements . Features [ codersdk . FeatureExternalTokenEncryption ]
entitled := feature . Entitlement == codersdk . EntitlementEntitled
var warningExists bool
for _ , warning := range entitlements . Warnings {
if strings . Contains ( warning , codersdk . FeatureExternalTokenEncryption . Humanize ()) {
warningExists = true
break
}
}
t . Logf ( "feature: %+v, warnings: %+v, errors: %+v" , feature , entitlements . Warnings , entitlements . Errors )
return feature . Enabled && entitled && ! warningExists
}, testutil . WaitShort , testutil . IntervalFast )
})
t . Run ( "Disabled" , func ( t * testing . T ) {
t . Parallel ()
ctx := testutil . Context ( t , testutil . WaitShort )
db , ps := dbtestutil . NewDB ( t )
ciphers , err := dbcrypt . NewCiphers ()
require . NoError ( t , err )
client , _ := coderdenttest . New ( t , & coderdenttest . Options {
DontAddLicense : true ,
EntitlementsUpdateInterval : 25 * time . Millisecond ,
ExternalTokenEncryption : ciphers ,
Options : & coderdtest . Options {
Database : db ,
Pubsub : ps ,
},
})
keys , err := db . GetDBCryptKeys ( ctx )
require . NoError ( t , err )
require . Empty ( t , keys )
require . Eventually ( t , func () bool {
entitlements , err := client . Entitlements ( context . Background ())
assert . NoError ( t , err )
feature := entitlements . Features [ codersdk . FeatureExternalTokenEncryption ]
entitled := feature . Entitlement == codersdk . EntitlementEntitled
var warningExists bool
for _ , warning := range entitlements . Warnings {
if strings . Contains ( warning , codersdk . FeatureExternalTokenEncryption . Humanize ()) {
warningExists = true
break
}
}
t . Logf ( "feature: %+v, warnings: %+v, errors: %+v" , feature , entitlements . Warnings , entitlements . Errors )
return ! feature . Enabled && ! entitled && ! warningExists
}, testutil . WaitShort , testutil . IntervalFast )
})
t . Run ( "PreviouslyEnabledButMissingFromLicense" , func ( t * testing . T ) {
// If this test fails, it potentially means that a customer who has
// actively been using this feature is now unable _start coderd_
// because of a licensing issue. This should never happen.
t . Parallel ()
ctx := testutil . Context ( t , testutil . WaitShort )
db , ps := dbtestutil . NewDB ( t )
ciphers , err := dbcrypt . NewCiphers ( bytes . Repeat ([] byte ( "a" ), 32 ))
require . NoError ( t , err )
dbc , err := dbcrypt . New ( ctx , db , ciphers ... ) // should insert key
require . NoError ( t , err )
keys , err := dbc . GetDBCryptKeys ( ctx )
require . NoError ( t , err )
require . Len ( t , keys , 1 )
client , _ := coderdenttest . New ( t , & coderdenttest . Options {
DontAddLicense : true ,
EntitlementsUpdateInterval : 25 * time . Millisecond ,
ExternalTokenEncryption : ciphers ,
Options : & coderdtest . Options {
Database : db ,
Pubsub : ps ,
},
})
require . Eventually ( t , func () bool {
entitlements , err := client . Entitlements ( context . Background ())
assert . NoError ( t , err )
feature := entitlements . Features [ codersdk . FeatureExternalTokenEncryption ]
entitled := feature . Entitlement == codersdk . EntitlementEntitled
var warningExists bool
for _ , warning := range entitlements . Warnings {
if strings . Contains ( warning , codersdk . FeatureExternalTokenEncryption . Humanize ()) {
warningExists = true
break
}
}
t . Logf ( "feature: %+v, warnings: %+v, errors: %+v" , feature , entitlements . Warnings , entitlements . Errors )
return feature . Enabled && ! entitled && warningExists
}, testutil . WaitShort , testutil . IntervalFast )
})
}
2024-03-21 16:53:41 -05:00
func TestMultiReplica_EmptyRelayAddress ( t * testing . T ) {
t . Parallel ()
ctx := testutil . Context ( t , testutil . WaitLong )
db , ps := dbtestutil . NewDB ( t )
2024-11-18 14:09:22 +04:00
logger := testutil . Logger ( t )
2024-03-21 16:53:41 -05:00
_ , _ = coderdenttest . New ( t , & coderdenttest . Options {
EntitlementsUpdateInterval : 25 * time . Millisecond ,
ReplicaSyncUpdateInterval : 25 * time . Millisecond ,
Options : & coderdtest . Options {
Logger : & logger ,
Database : db ,
Pubsub : ps ,
},
})
mgr , err := replicasync . New ( ctx , logger , db , ps , & replicasync . Options {
ID : uuid . New (),
RelayAddress : "" ,
RegionID : 999 ,
UpdateInterval : testutil . IntervalFast ,
})
require . NoError ( t , err )
defer mgr . Close ()
// Send a bunch of updates to see if the coderd will log errors.
{
ctx , cancel := context . WithTimeout ( ctx , testutil . IntervalMedium )
for r := retry . New ( testutil . IntervalFast , testutil . IntervalFast ); r . Wait ( ctx ); {
require . NoError ( t , mgr . PublishUpdate ())
}
cancel ()
}
}
func TestMultiReplica_EmptyRelayAddress_DisabledDERP ( t * testing . T ) {
t . Parallel ()
2024-08-30 18:43:51 +10:00
derpMap , _ := tailnettest . RunDERPAndSTUN ( t )
srv := httptest . NewServer ( http . HandlerFunc ( func ( w http . ResponseWriter , r * http . Request ) {
httpapi . Write ( context . Background (), w , http . StatusOK , derpMap )
}))
t . Cleanup ( srv . Close )
2024-03-21 16:53:41 -05:00
ctx := testutil . Context ( t , testutil . WaitLong )
db , ps := dbtestutil . NewDB ( t )
2024-11-18 14:09:22 +04:00
logger := testutil . Logger ( t )
2024-03-21 16:53:41 -05:00
dv := coderdtest . DeploymentValues ( t )
dv . DERP . Server . Enable = serpent . Bool ( false )
2024-08-30 18:43:51 +10:00
dv . DERP . Config . URL = serpent . String ( srv . URL )
2024-03-21 16:53:41 -05:00
_ , _ = coderdenttest . New ( t , & coderdenttest . Options {
EntitlementsUpdateInterval : 25 * time . Millisecond ,
ReplicaSyncUpdateInterval : 25 * time . Millisecond ,
Options : & coderdtest . Options {
Logger : & logger ,
Database : db ,
Pubsub : ps ,
DeploymentValues : dv ,
},
})
mgr , err := replicasync . New ( ctx , logger , db , ps , & replicasync . Options {
ID : uuid . New (),
RelayAddress : "" ,
RegionID : 999 ,
UpdateInterval : testutil . IntervalFast ,
})
require . NoError ( t , err )
defer mgr . Close ()
// Send a bunch of updates to see if the coderd will log errors.
{
ctx , cancel := context . WithTimeout ( ctx , testutil . IntervalMedium )
for r := retry . New ( testutil . IntervalFast , testutil . IntervalFast ); r . Wait ( ctx ); {
require . NoError ( t , mgr . PublishUpdate ())
}
cancel ()
}
}
2024-10-24 16:26:16 -04:00
func TestSCIMDisabled ( t * testing . T ) {
t . Parallel ()
cli , _ := coderdenttest . New ( t , & coderdenttest . Options {})
checkPaths := [] string {
"/scim/v2" ,
"/scim/v2/" ,
"/scim/v2/users" ,
"/scim/v2/Users" ,
"/scim/v2/Users/" ,
"/scim/v2/random/path/that/is/long" ,
"/scim/v2/random/path/that/is/long.txt" ,
}
for _ , p := range checkPaths {
t . Run ( p , func ( t * testing . T ) {
t . Parallel ()
u , err := cli . URL . Parse ( p )
require . NoError ( t , err )
req , err := http . NewRequestWithContext ( context . Background (), http . MethodGet , u . String (), nil )
require . NoError ( t , err )
resp , err := http . DefaultClient . Do ( req )
require . NoError ( t , err )
defer resp . Body . Close ()
require . Equal ( t , http . StatusNotFound , resp . StatusCode )
var apiError codersdk . Response
err = json . NewDecoder ( resp . Body ). Decode ( & apiError )
require . NoError ( t , err )
require . Contains ( t , apiError . Message , "SCIM is disabled" )
})
}
}
2025-07-22 13:39:26 +10:00
func TestManagedAgentLimit ( t * testing . T ) {
t . Parallel ()
2025-07-22 16:03:35 +10:00
ctx := testutil . Context ( t , testutil . WaitLong )
2025-07-22 13:39:26 +10:00
cli , _ := coderdenttest . New ( t , & coderdenttest . Options {
Options : & coderdtest . Options {
IncludeProvisionerDaemon : true ,
},
2025-07-22 16:03:35 +10:00
LicenseOptions : ( & coderdenttest . LicenseOptions {
FeatureSet : codersdk . FeatureSetPremium ,
// Make it expire in the distant future so it doesn't generate
// expiry warnings.
GraceAt : time . Now (). Add ( time . Hour * 24 * 60 ),
ExpiresAt : time . Now (). Add ( time . Hour * 24 * 90 ),
}). ManagedAgentLimit ( 1 , 1 ),
2025-07-22 13:39:26 +10:00
})
2025-07-22 16:03:35 +10:00
// Get entitlements to check that the license is a-ok.
entitlements , err := cli . Entitlements ( ctx ) //nolint:gocritic // we're not testing authz on the entitlements endpoint, so using owner is fine
require . NoError ( t , err )
require . True ( t , entitlements . HasLicense )
agentLimit := entitlements . Features [ codersdk . FeatureManagedAgentLimit ]
require . True ( t , agentLimit . Enabled )
require . NotNil ( t , agentLimit . Limit )
require . EqualValues ( t , 1 , * agentLimit . Limit )
require . NotNil ( t , agentLimit . SoftLimit )
require . EqualValues ( t , 1 , * agentLimit . SoftLimit )
require . Empty ( t , entitlements . Errors )
// There should be a warning since we're really close to our agent limit.
require . Equal ( t , entitlements . Warnings [ 0 ], "You are approaching the managed agent limit in your license. Please refer to the Deployment Licenses page for more information." )
// Create a fake provision response that claims there are agents in the
// template and every built workspace.
//
2025-07-22 13:39:26 +10:00
// It's fine that the app ID is only used in a single successful workspace
// build.
appID := uuid . NewString ()
echoRes := & echo . Responses {
Parse : echo . ParseComplete ,
ProvisionPlan : [] * proto . Response {
{
Type : & proto . Response_Plan {
Plan : & proto . PlanComplete {
Plan : [] byte ( "{}" ),
ModuleFiles : [] byte {},
HasAiTasks : true ,
},
},
},
},
ProvisionApply : [] * proto . Response {{
Type : & proto . Response_Apply {
Apply : & proto . ApplyComplete {
Resources : [] * proto . Resource {{
Name : "example" ,
Type : "aws_instance" ,
Agents : [] * proto . Agent {{
Id : uuid . NewString (),
Name : "example" ,
Auth : & proto . Agent_Token {
Token : uuid . NewString (),
},
Apps : [] * proto . App {{
Id : appID ,
Slug : "test" ,
Url : "http://localhost:1234" ,
}},
}},
}},
AiTasks : [] * proto . AITask {{
Id : uuid . NewString (),
SidebarApp : & proto . AITaskSidebarApp {
Id : appID ,
},
}},
},
},
}},
}
// Create two templates, one with AI and one without.
aiVersion := coderdtest . CreateTemplateVersion ( t , cli , uuid . Nil , echoRes )
coderdtest . AwaitTemplateVersionJobCompleted ( t , cli , aiVersion . ID )
aiTemplate := coderdtest . CreateTemplate ( t , cli , uuid . Nil , aiVersion . ID )
noAiVersion := coderdtest . CreateTemplateVersion ( t , cli , uuid . Nil , nil ) // use default responses
coderdtest . AwaitTemplateVersionJobCompleted ( t , cli , noAiVersion . ID )
noAiTemplate := coderdtest . CreateTemplate ( t , cli , uuid . Nil , noAiVersion . ID )
// Create one AI workspace, which should succeed.
workspace := coderdtest . CreateWorkspace ( t , cli , aiTemplate . ID )
coderdtest . AwaitWorkspaceBuildJobCompleted ( t , cli , workspace . LatestBuild . ID )
// Create a second AI workspace, which should fail. This needs to be done
// manually because coderdtest.CreateWorkspace expects it to succeed.
2025-07-22 16:03:35 +10:00
_ , err = cli . CreateUserWorkspace ( ctx , codersdk . Me , codersdk . CreateWorkspaceRequest { //nolint:gocritic // owners must still be subject to the limit
2025-07-22 13:39:26 +10:00
TemplateID : aiTemplate . ID ,
Name : coderdtest . RandomUsername ( t ),
AutomaticUpdates : codersdk . AutomaticUpdatesNever ,
})
require . ErrorContains ( t , err , "You have breached the managed agent limit in your license" )
// Create a third non-AI workspace, which should succeed.
workspace = coderdtest . CreateWorkspace ( t , cli , noAiTemplate . ID )
coderdtest . AwaitWorkspaceBuildJobCompleted ( t , cli , workspace . LatestBuild . ID )
}
2023-02-15 16:14:37 +00:00
// testDBAuthzRole returns a context with a subject that has a role
// with permissions required for test setup.
func testDBAuthzRole ( ctx context . Context ) context . Context {
return dbauthz . As ( ctx , rbac . Subject {
ID : uuid . Nil . String (),
Roles : rbac . Roles ([] rbac . Role {
{
2024-06-11 08:55:28 -05:00
Identifier : rbac . RoleIdentifier { Name : "testing" },
2023-02-15 16:14:37 +00:00
DisplayName : "Unit Tests" ,
2024-05-15 09:46:35 -05:00
Site : rbac . Permissions ( map [ string ][] policy . Action {
2024-05-15 11:09:42 -05:00
rbac . ResourceWildcard . Type : { policy . WildcardSymbol },
2023-02-15 16:14:37 +00:00
}),
Org : map [ string ][] rbac . Permission {},
User : [] rbac . Permission {},
},
}),
Scope : rbac . ScopeAll ,
})
}
2024-11-20 17:04:33 +10:00
// restartableListener is a TCP listener that can have all of it's connections
// severed on demand.
type restartableListener struct {
net . Listener
mu sync . Mutex
conns [] net . Conn
}
func ( l * restartableListener ) Accept () ( net . Conn , error ) {
conn , err := l . Listener . Accept ()
if err != nil {
return nil , err
}
l . mu . Lock ()
l . conns = append ( l . conns , conn )
l . mu . Unlock ()
return conn , nil
}
func ( l * restartableListener ) CloseConnections () {
l . mu . Lock ()
defer l . mu . Unlock ()
for _ , conn := range l . conns {
_ = conn . Close ()
}
l . conns = nil
}
type restartableTestServer struct {
options * coderdenttest . Options
rl * restartableListener
mu sync . Mutex
api * coderd . API
closer io . Closer
}
func newRestartableTestServer ( t * testing . T , options * coderdenttest . Options ) ( * codersdk . Client , codersdk . CreateFirstUserResponse , * restartableTestServer ) {
t . Helper ()
if options == nil {
options = & coderdenttest . Options {}
}
s := & restartableTestServer {
options : options ,
}
srv := httptest . NewUnstartedServer ( http . HandlerFunc ( func ( w http . ResponseWriter , r * http . Request ) {
s . mu . Lock ()
api := s . api
s . mu . Unlock ()
if api == nil {
w . WriteHeader ( http . StatusBadGateway )
_ , _ = w . Write ([] byte ( "server is not started" ))
return
}
api . AGPL . RootHandler . ServeHTTP ( w , r )
}))
s . rl = & restartableListener { Listener : srv . Listener }
srv . Listener = s . rl
srv . Start ()
t . Cleanup ( srv . Close )
u , err := url . Parse ( srv . URL )
require . NoError ( t , err , "failed to parse server URL" )
s . options . AccessURL = u
client , firstUser := s . startWithFirstUser ( t )
client . URL = u
return client , firstUser , s
}
func ( s * restartableTestServer ) Stop ( t * testing . T ) {
t . Helper ()
s . mu . Lock ()
closer := s . closer
s . closer = nil
api := s . api
s . api = nil
s . mu . Unlock ()
if closer != nil {
err := closer . Close ()
require . NoError ( t , err )
}
if api != nil {
err := api . Close ()
require . NoError ( t , err )
}
s . rl . CloseConnections ()
}
func ( s * restartableTestServer ) Start ( t * testing . T ) {
t . Helper ()
_ , _ = s . startWithFirstUser ( t )
}
func ( s * restartableTestServer ) startWithFirstUser ( t * testing . T ) ( client * codersdk . Client , firstUser codersdk . CreateFirstUserResponse ) {
t . Helper ()
s . mu . Lock ()
defer s . mu . Unlock ()
if s . closer != nil || s . api != nil {
t . Fatal ( "server already started, close must be called first" )
}
// This creates it's own TCP listener unfortunately, but it's not being
// used in this test.
client , s . closer , s . api , firstUser = coderdenttest . NewWithAPI ( t , s . options )
// Never add the first user or license on subsequent restarts.
s . options . DontAddFirstUser = true
s . options . DontAddLicense = true
return client , firstUser
}
// Test_CoordinatorRollingRestart tests that two peers can maintain a connection
// without forgetting about each other when a HA coordinator does a rolling
// restart.
//
// We had a few issues with this in the past:
// 1. We didn't allow clients to maintain their peer ID after a reconnect,
// which resulted in the other peer thinking the client was a new peer.
// (This is fixed and independently tested in AGPL code)
// 2. HA coordinators would delete all peers (via FK constraints) when they
// were closed, which meant tunnels would be deleted and peers would be
// notified that the other peer was permanently gone.
// (This is fixed and independently tested above)
//
// This test uses a real server and real clients.
func TestConn_CoordinatorRollingRestart ( t * testing . T ) {
t . Parallel ()
if ! dbtestutil . WillUsePostgres () {
t . Skip ( "test only with postgres" )
}
// Although DERP will have connection issues until the connection is
// reestablished, any open connections should be maintained.
//
// Direct connections should be able to transmit packets throughout the
// restart without issue.
//nolint:paralleltest // Outdated rule
for _ , direct := range [] bool { true , false } {
name := "DERP"
if direct {
name = "Direct"
}
t . Run ( name , func ( t * testing . T ) {
t . Parallel ()
store , ps := dbtestutil . NewDB ( t )
dv := coderdtest . DeploymentValues ( t , func ( dv * codersdk . DeploymentValues ) {
dv . DERP . Config . BlockDirect = serpent . Bool (! direct )
})
logger := slogtest . Make ( t , & slogtest . Options { IgnoreErrors : true }). Leveled ( slog . LevelDebug )
// Create two restartable test servers with the same database.
client1 , user , s1 := newRestartableTestServer ( t , & coderdenttest . Options {
DontAddFirstUser : false ,
DontAddLicense : false ,
Options : & coderdtest . Options {
Logger : ptr . Ref ( logger . Named ( "server1" )),
Database : store ,
Pubsub : ps ,
DeploymentValues : dv ,
IncludeProvisionerDaemon : true ,
},
LicenseOptions : & coderdenttest . LicenseOptions {
Features : license . Features {
codersdk . FeatureHighAvailability : 1 ,
},
},
})
client2 , _ , s2 := newRestartableTestServer ( t , & coderdenttest . Options {
DontAddFirstUser : true ,
DontAddLicense : true ,
Options : & coderdtest . Options {
Logger : ptr . Ref ( logger . Named ( "server2" )),
Database : store ,
Pubsub : ps ,
DeploymentValues : dv ,
},
})
client2 . SetSessionToken ( client1 . SessionToken ())
workspace := dbfake . WorkspaceBuild ( t , store , database . WorkspaceTable {
OrganizationID : user . OrganizationID ,
OwnerID : user . UserID ,
}). WithAgent (). Do ()
// Agent connects via the first coordinator.
_ = agenttest . New ( t , client1 . URL , workspace . AgentToken , func ( o * agent . Options ) {
o . Logger = logger . Named ( "agent1" )
})
resources := coderdtest . NewWorkspaceAgentWaiter ( t , client1 , workspace . Workspace . ID ). Wait ()
agentID := uuid . Nil
for _ , r := range resources {
for _ , a := range r . Agents {
agentID = a . ID
break
}
}
require . NotEqual ( t , uuid . Nil , agentID )
// Client connects via the second coordinator.
ctx := testutil . Context ( t , testutil . WaitSuperLong )
workspaceClient2 := workspacesdk . New ( client2 )
conn , err := workspaceClient2 . DialAgent ( ctx , agentID , & workspacesdk . DialAgentOptions {
Logger : logger . Named ( "client" ),
})
require . NoError ( t , err )
defer conn . Close ()
require . Eventually ( t , func () bool {
_ , p2p , _ , err := conn . Ping ( ctx )
assert . NoError ( t , err )
return p2p == direct
}, testutil . WaitShort , testutil . IntervalFast )
// Open a TCP server and connection to it through the tunnel that
// should be maintained throughout the restart.
tcpServerAddr := tcpEchoServer ( t )
tcpConn , err := conn . DialContext ( ctx , "tcp" , tcpServerAddr )
require . NoError ( t , err )
defer tcpConn . Close ()
writeReadEcho ( t , ctx , tcpConn )
// Stop the first server.
logger . Info ( ctx , "test: stopping server 1" )
s1 . Stop ( t )
// Pings should fail on DERP but succeed on direct connections.
pingCtx , pingCancel := context . WithTimeout ( ctx , 2 * time . Second ) //nolint:gocritic // it's going to hang and timeout for DERP, so this needs to be short
defer pingCancel ()
_ , p2p , _ , err := conn . Ping ( pingCtx )
if direct {
require . NoError ( t , err )
require . True ( t , p2p , "expected direct connection" )
} else {
require . ErrorIs ( t , err , context . DeadlineExceeded )
}
// The existing TCP connection should still be working if we're
// using direct connections.
if direct {
writeReadEcho ( t , ctx , tcpConn )
}
// Start the first server again.
logger . Info ( ctx , "test: starting server 1" )
s1 . Start ( t )
// Restart the second server.
logger . Info ( ctx , "test: stopping server 2" )
s2 . Stop ( t )
logger . Info ( ctx , "test: starting server 2" )
s2 . Start ( t )
// Pings should eventually succeed on both DERP and direct
// connections.
require . True ( t , conn . AwaitReachable ( ctx ))
_ , p2p , _ , err = conn . Ping ( ctx )
require . NoError ( t , err )
require . Equal ( t , direct , p2p , "mismatched p2p state" )
// The existing TCP connection should still be working.
writeReadEcho ( t , ctx , tcpConn )
})
}
}
func tcpEchoServer ( t * testing . T ) string {
tcpListener , err := net . Listen ( "tcp" , "127.0.0.1:0" )
require . NoError ( t , err )
t . Cleanup ( func () {
_ = tcpListener . Close ()
})
go func () {
for {
conn , err := tcpListener . Accept ()
if err != nil {
return
}
2024-11-22 11:44:56 +04:00
t . Cleanup ( func () {
_ = conn . Close ()
})
2024-11-20 17:04:33 +10:00
go func () {
defer conn . Close ()
_ , _ = io . Copy ( conn , conn )
}()
}
}()
return tcpListener . Addr (). String ()
}
// nolint:revive // t takes precedence.
func writeReadEcho ( t * testing . T , ctx context . Context , conn net . Conn ) {
msg := namesgenerator . GetRandomName ( 0 )
deadline , ok := ctx . Deadline ()
if ok {
_ = conn . SetWriteDeadline ( deadline )
defer conn . SetWriteDeadline ( time . Time {})
_ = conn . SetReadDeadline ( deadline )
defer conn . SetReadDeadline ( time . Time {})
}
// Write a message
_ , err := conn . Write ([] byte ( msg ))
require . NoError ( t , err )
// Read the message back
buf := make ([] byte , 1024 )
n , err := conn . Read ( buf )
require . NoError ( t , err )
require . Equal ( t , msg , string ( buf [: n ]))
}