2022-01-20 07:46:51 -06:00
package coderd_test
import (
"context"
2022-04-22 15:27:55 -05:00
"fmt"
2022-01-24 17:09:39 -08:00
"net/http"
2025-03-03 21:46:49 +08:00
"slices"
2022-05-27 16:47:03 -04:00
"strings"
2022-01-20 07:46:51 -06:00
"testing"
2022-06-01 14:58:55 -05:00
"time"
2022-01-20 07:46:51 -06:00
2023-08-25 14:34:07 -05:00
"github.com/golang-jwt/jwt/v4"
2022-03-07 11:40:54 -06:00
"github.com/google/uuid"
2023-05-18 20:54:45 -04:00
"github.com/stretchr/testify/assert"
2022-01-20 10:00:13 -06:00
"github.com/stretchr/testify/require"
2022-08-09 20:17:00 +03:00
"golang.org/x/sync/errgroup"
2024-07-09 14:28:39 -05:00
"golang.org/x/xerrors"
2022-01-20 10:00:13 -06:00
2026-01-08 15:24:11 +04:00
"github.com/coder/coder/v2/coderd"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/audit"
"github.com/coder/coder/v2/coderd/coderdtest"
2026-01-08 15:24:11 +04:00
"github.com/coder/coder/v2/coderd/coderdtest/oidctest"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/database"
2026-06-10 02:18:44 -05:00
"github.com/coder/coder/v2/coderd/database/dbauthz"
2024-01-30 16:02:21 -06:00
"github.com/coder/coder/v2/coderd/database/dbfake"
2023-12-04 11:05:17 -05:00
"github.com/coder/coder/v2/coderd/database/dbgen"
2023-09-01 19:50:12 +03:00
"github.com/coder/coder/v2/coderd/database/dbtime"
2026-01-08 15:24:11 +04:00
"github.com/coder/coder/v2/coderd/notifications"
"github.com/coder/coder/v2/coderd/notifications/notificationstest"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/rbac"
2026-01-08 15:24:11 +04:00
"github.com/coder/coder/v2/coderd/rbac/policy"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/util/slice"
"github.com/coder/coder/v2/codersdk"
"github.com/coder/coder/v2/testutil"
2026-01-08 15:24:11 +04:00
"github.com/coder/serpent"
2022-01-20 07:46:51 -06:00
)
2022-03-07 11:40:54 -06:00
func TestFirstUser ( t * testing . T ) {
2022-01-20 07:46:51 -06:00
t . Parallel ()
2022-02-05 18:24:51 -06:00
t . Run ( "BadRequest" , func ( t * testing . T ) {
2022-01-20 07:46:51 -06:00
t . Parallel ()
2022-02-21 14:36:29 -06:00
client := coderdtest . New ( t , nil )
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2022-09-19 23:11:01 -05:00
has , err := client . HasFirstUser ( context . Background ())
require . NoError ( t , err )
require . False ( t , has )
_ , err = client . CreateFirstUser ( ctx , codersdk . CreateFirstUserRequest {})
2022-01-20 07:46:51 -06:00
require . Error ( t , err )
})
2022-02-05 18:24:51 -06:00
t . Run ( "AlreadyExists" , func ( t * testing . T ) {
2022-01-24 11:07:42 -06:00
t . Parallel ()
2022-02-21 14:36:29 -06:00
client := coderdtest . New ( t , nil )
2022-03-07 11:40:54 -06:00
_ = coderdtest . CreateFirstUser ( t , client )
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
_ , err := client . CreateFirstUser ( ctx , codersdk . CreateFirstUserRequest {
2022-11-16 17:09:49 -06:00
Email : "some@email.com" ,
Username : "exampleuser" ,
2023-02-08 14:10:08 -06:00
Password : "SomeSecurePassword!" ,
2022-02-05 18:24:51 -06:00
})
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
require . Equal ( t , http . StatusConflict , apiErr . StatusCode ())
})
t . Run ( "Create" , func ( t * testing . T ) {
t . Parallel ()
2024-06-26 09:00:42 +01:00
ctx := testutil . Context ( t , testutil . WaitShort )
2022-02-21 14:36:29 -06:00
client := coderdtest . New ( t , nil )
2022-03-07 11:40:54 -06:00
_ = coderdtest . CreateFirstUser ( t , client )
2024-06-26 09:00:42 +01:00
u , err := client . User ( ctx , codersdk . Me )
require . NoError ( t , err )
assert . Equal ( t , coderdtest . FirstUserParams . Name , u . Name )
assert . Equal ( t , coderdtest . FirstUserParams . Email , u . Email )
assert . Equal ( t , coderdtest . FirstUserParams . Username , u . Username )
2022-02-17 20:09:33 -08:00
})
2022-08-26 05:32:35 +10:00
2022-11-16 17:09:49 -06:00
t . Run ( "Trial" , func ( t * testing . T ) {
t . Parallel ()
2026-09-01 11:15:02 -06:00
trialGenerated := make ( chan codersdk . LicensorTrialRequest , 1 )
2024-02-23 17:48:24 +01:00
entitlementsRefreshed := make ( chan struct {})
2022-11-16 17:09:49 -06:00
client := coderdtest . New ( t , & coderdtest . Options {
2026-09-01 11:15:02 -06:00
TrialGenerator : func ( _ context . Context , req codersdk . LicensorTrialRequest ) error {
trialGenerated <- req
2024-02-23 17:48:24 +01:00
return nil
},
RefreshEntitlements : func ( context . Context ) error {
close ( entitlementsRefreshed )
2022-11-16 17:09:49 -06:00
return nil
},
})
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
req := codersdk . CreateFirstUserRequest {
Email : "testuser@coder.com" ,
Username : "testuser" ,
2024-06-26 09:00:42 +01:00
Name : "Test User" ,
2023-02-08 14:10:08 -06:00
Password : "SomeSecurePassword!" ,
2022-11-16 17:09:49 -06:00
Trial : true ,
}
_ , err := client . CreateFirstUser ( ctx , req )
require . NoError ( t , err )
2024-02-23 17:48:24 +01:00
2026-09-01 11:15:02 -06:00
trialReq := testutil . TryReceive ( ctx , t , trialGenerated )
require . Equal ( t , codersdk . LicensorTrialSourceNewUser , trialReq . Source )
2025-04-16 09:37:09 -07:00
_ = testutil . TryReceive ( ctx , t , entitlementsRefreshed )
2022-11-16 17:09:49 -06:00
})
2022-02-17 20:09:33 -08:00
}
2026-04-03 09:52:52 -04:00
func TestFirstUser_OnboardingTelemetry ( t * testing . T ) {
t . Parallel ()
t . Run ( "OnboardingInfoFlowsToSnapshot" , func ( t * testing . T ) {
t . Parallel ()
ctx := testutil . Context ( t , testutil . WaitMedium )
fTelemetry := newFakeTelemetryReporter ( ctx , t , 10 )
client := coderdtest . New ( t , & coderdtest . Options {
TelemetryReporter : fTelemetry ,
})
_ , err := client . CreateFirstUser ( ctx , codersdk . CreateFirstUserRequest {
Email : "admin@coder.com" ,
Username : "admin" ,
Password : "SomeSecurePassword!" ,
OnboardingInfo : & codersdk . CreateFirstUserOnboardingInfo {
2026-04-03 14:26:35 -04:00
NewsletterMarketing : false ,
NewsletterReleases : true ,
2026-04-03 09:52:52 -04:00
},
})
require . NoError ( t , err )
snapshot := testutil . TryReceive ( ctx , t , fTelemetry . snapshots )
require . NotNil ( t , snapshot . FirstUserOnboarding )
2026-04-03 14:26:35 -04:00
require . False ( t , snapshot . FirstUserOnboarding . NewsletterMarketing )
require . True ( t , snapshot . FirstUserOnboarding . NewsletterReleases )
2026-04-03 09:52:52 -04:00
})
t . Run ( "NilWhenOnboardingInfoOmitted" , func ( t * testing . T ) {
t . Parallel ()
ctx := testutil . Context ( t , testutil . WaitMedium )
fTelemetry := newFakeTelemetryReporter ( ctx , t , 10 )
client := coderdtest . New ( t , & coderdtest . Options {
TelemetryReporter : fTelemetry ,
})
_ , err := client . CreateFirstUser ( ctx , codersdk . CreateFirstUserRequest {
Email : "admin@coder.com" ,
Username : "admin" ,
Password : "SomeSecurePassword!" ,
// No OnboardingInfo — simulates old CLI or OIDC flow.
})
require . NoError ( t , err )
snapshot := testutil . TryReceive ( ctx , t , fTelemetry . snapshots )
require . Nil ( t , snapshot . FirstUserOnboarding )
})
t . Run ( "EmptyOnboardingInfoIsNonNilWithZeroFields" , func ( t * testing . T ) {
t . Parallel ()
ctx := testutil . Context ( t , testutil . WaitMedium )
fTelemetry := newFakeTelemetryReporter ( ctx , t , 10 )
client := coderdtest . New ( t , & coderdtest . Options {
TelemetryReporter : fTelemetry ,
})
_ , err := client . CreateFirstUser ( ctx , codersdk . CreateFirstUserRequest {
Email : "admin@coder.com" , Username : "admin" ,
Password : "SomeSecurePassword!" ,
OnboardingInfo : & codersdk . CreateFirstUserOnboardingInfo {},
})
require . NoError ( t , err )
snapshot := testutil . TryReceive ( ctx , t , fTelemetry . snapshots )
require . NotNil ( t , snapshot . FirstUserOnboarding ,
"non-nil OnboardingInfo must produce non-nil telemetry" )
2026-04-03 14:26:35 -04:00
require . False ( t , snapshot . FirstUserOnboarding . NewsletterMarketing )
require . False ( t , snapshot . FirstUserOnboarding . NewsletterReleases )
2026-04-03 09:52:52 -04:00
})
}
2022-02-05 18:24:51 -06:00
func TestPostLogin ( t * testing . T ) {
t . Parallel ()
t . Run ( "InvalidUser" , func ( t * testing . T ) {
t . Parallel ()
2023-03-22 12:52:13 -07:00
client := coderdtest . New ( t , nil )
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
_ , err := client . LoginWithPassword ( ctx , codersdk . LoginWithPasswordRequest {
2022-02-05 18:24:51 -06:00
Email : "my@email.org" ,
Password : "password" ,
})
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
require . Equal ( t , http . StatusUnauthorized , apiErr . StatusCode ())
})
t . Run ( "BadPassword" , func ( t * testing . T ) {
t . Parallel ()
2023-02-06 15:12:50 -05:00
auditor := audit . NewMock ()
client := coderdtest . New ( t , & coderdtest . Options { Auditor : auditor })
2023-03-30 12:13:03 -05:00
numLogs := len ( auditor . AuditLogs ())
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2022-03-22 13:17:50 -06:00
req := 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-03-07 11:40:54 -06:00
}
2022-08-09 20:17:00 +03:00
_ , err := client . CreateFirstUser ( ctx , req )
2022-03-07 11:40:54 -06:00
require . NoError ( t , err )
2022-08-09 20:17:00 +03:00
_ , err = client . LoginWithPassword ( ctx , codersdk . LoginWithPasswordRequest {
2022-03-07 11:40:54 -06:00
Email : req . Email ,
2022-02-05 18:24:51 -06:00
Password : "badpass" ,
})
2023-02-06 15:12:50 -05:00
numLogs ++ // add an audit log for login
2022-02-05 18:24:51 -06:00
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
require . Equal ( t , http . StatusUnauthorized , apiErr . StatusCode ())
2023-02-06 15:12:50 -05:00
2023-03-30 12:13:03 -05:00
require . Len ( t , auditor . AuditLogs (), numLogs )
require . Equal ( t , database . AuditActionLogin , auditor . AuditLogs ()[ numLogs - 1 ]. Action )
2022-02-05 18:24:51 -06:00
})
2026-06-10 02:18:44 -05:00
// "hunter2" was the input of the previous hardcoded simulated hash, which
// an empty stored hash wrongly matched; this is a regression test.
t . Run ( "NonexistentUser401" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
_ , err := client . LoginWithPassword ( ctx , codersdk . LoginWithPasswordRequest {
Email : "does-not-exist@coder.com" ,
Password : "hunter2" ,
})
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
require . Equal ( t , http . StatusUnauthorized , apiErr . StatusCode ())
require . Equal ( t , "Incorrect email or password." , apiErr . Message )
})
// Attempting built-in login as an SSO user returns a 401 to avoid
// divulging login type.
t . Run ( "SSOReturns401" , func ( t * testing . T ) {
t . Parallel ()
client , db := coderdtest . NewWithDatabase ( t , nil )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
// An SSO user has no password hash stored. Create one directly in the
// database since the API requires OIDC to be configured. dbgen.User
// substitutes a random hash for an empty one, so clear it explicitly.
ssoUser := dbgen . User ( t , db , database . User {
Email : "sso-user@coder.com" ,
LoginType : database . LoginTypeOIDC ,
})
//nolint:gocritic // Test setup requires a system context to clear the hash.
err := db . UpdateUserHashedPassword ( dbauthz . AsSystemRestricted ( ctx ), database . UpdateUserHashedPasswordParams {
ID : ssoUser . ID ,
HashedPassword : [] byte {},
})
require . NoError ( t , err )
anonClient := codersdk . New ( client . URL )
_ , err = anonClient . LoginWithPassword ( ctx , codersdk . LoginWithPasswordRequest {
Email : ssoUser . Email ,
Password : "hunter2" ,
})
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
require . Equal ( t , http . StatusUnauthorized , apiErr . StatusCode ())
require . Equal ( t , "Incorrect email or password." , apiErr . Message )
// The login type must not be leaked.
require . NotContains ( t , apiErr . Message , string ( codersdk . LoginTypeOIDC ))
})
2026-07-28 21:05:50 +10:00
// Regression: the legacy `login_type = 'none'` migration converts these
// accounts to password auth, but they have no password hash. Converting
// login type must never let someone authenticate with an empty or guessed
// password.
t . Run ( "ConvertedNoneUserHasNoUsablePassword" , func ( t * testing . T ) {
t . Parallel ()
client , db := coderdtest . NewWithDatabase ( t , nil )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
// A legacy machine user was created with login_type 'none' and no
// password. dbgen.User substitutes a random hash for an empty one, so
// clear it explicitly to match the real account.
noneUser := dbgen . User ( t , db , database . User {
Email : "legacy-machine-user@coder.com" ,
LoginType : database . LoginTypeNone ,
})
//nolint:gocritic // Test setup requires a system context to clear the hash.
err := db . UpdateUserHashedPassword ( dbauthz . AsSystemRestricted ( ctx ), database . UpdateUserHashedPasswordParams {
ID : noneUser . ID ,
HashedPassword : [] byte {},
})
require . NoError ( t , err )
// Apply the migration's conversion: login_type 'none' -> 'password'.
//nolint:gocritic // Test setup requires a system context to convert the login type.
_ , err = db . UpdateUserLoginType ( dbauthz . AsSystemRestricted ( ctx ), database . UpdateUserLoginTypeParams {
NewLoginType : database . LoginTypePassword ,
UserID : noneUser . ID ,
})
require . NoError ( t , err )
// Neither an empty password nor a guessed one may authenticate. An empty
// password is rejected by request validation (400); a non-empty guess
// fails the hash comparison against the empty stored hash (401). Both must
// deny access.
cases := [] struct {
name string
password string
wantStatus int
}{
{ "EmptyPassword" , "" , http . StatusBadRequest },
{ "GuessedPassword" , "hunter2" , http . StatusUnauthorized },
}
for _ , tc := range cases {
anonClient := codersdk . New ( client . URL )
_ , err := anonClient . LoginWithPassword ( ctx , codersdk . LoginWithPasswordRequest {
Email : noneUser . Email ,
Password : tc . password ,
})
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr , "%s must not authenticate" , tc . name )
require . Equal ( t , tc . wantStatus , apiErr . StatusCode (), "%s" , tc . name )
}
})
2022-05-31 08:06:42 -05:00
t . Run ( "Suspended" , func ( t * testing . T ) {
t . Parallel ()
2023-02-06 15:12:50 -05:00
auditor := audit . NewMock ()
client := coderdtest . New ( t , & coderdtest . Options { Auditor : auditor })
2023-03-30 12:13:03 -05:00
numLogs := len ( auditor . AuditLogs ())
2022-05-31 08:06:42 -05:00
first := coderdtest . CreateFirstUser ( t , client )
2023-02-06 15:12:50 -05:00
numLogs ++ // add an audit log for create user
numLogs ++ // add an audit log for login
2022-05-31 08:06:42 -05:00
2023-02-06 17:48:21 -06:00
member , _ := coderdtest . CreateAnotherUser ( t , client , first . OrganizationID )
2023-02-06 15:12:50 -05:00
numLogs ++ // add an audit log for create user
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
memberUser , err := member . User ( ctx , codersdk . Me )
2022-05-31 08:06:42 -05:00
require . NoError ( t , err , "fetch member user" )
2022-08-09 20:17:00 +03:00
_ , err = client . UpdateUserStatus ( ctx , memberUser . Username , codersdk . UserStatusSuspended )
2022-05-31 08:06:42 -05:00
require . NoError ( t , err , "suspend member" )
2023-02-06 15:12:50 -05:00
numLogs ++ // add an audit log for update user
2022-05-31 08:06:42 -05:00
// Test an existing session
2022-08-09 20:17:00 +03:00
_ , err = member . User ( ctx , codersdk . Me )
2022-05-31 08:06:42 -05:00
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
require . Equal ( t , http . StatusUnauthorized , apiErr . StatusCode ())
2022-06-03 16:48:09 -05:00
require . Contains ( t , apiErr . Message , "Contact an admin" )
2022-05-31 08:06:42 -05:00
// Test a new session
2022-08-09 20:17:00 +03:00
_ , err = client . LoginWithPassword ( ctx , codersdk . LoginWithPasswordRequest {
2022-05-31 08:06:42 -05:00
Email : memberUser . Email ,
2023-02-08 14:10:08 -06:00
Password : "SomeSecurePassword!" ,
2022-05-31 08:06:42 -05:00
})
2023-02-06 15:12:50 -05:00
numLogs ++ // add an audit log for login
2022-05-31 08:06:42 -05:00
require . ErrorAs ( t , err , & apiErr )
require . Equal ( t , http . StatusUnauthorized , apiErr . StatusCode ())
require . Contains ( t , apiErr . Message , "suspended" )
2023-02-06 15:12:50 -05:00
2023-03-30 12:13:03 -05:00
require . Len ( t , auditor . AuditLogs (), numLogs )
require . Equal ( t , database . AuditActionLogin , auditor . AuditLogs ()[ numLogs - 1 ]. Action )
2022-05-31 08:06:42 -05:00
})
2023-02-07 01:58:21 +11:00
t . Run ( "DisabledPasswordAuth" , func ( t * testing . T ) {
t . Parallel ()
2023-03-07 15:10:01 -06:00
dc := coderdtest . DeploymentValues ( t )
2023-02-07 01:58:21 +11:00
client := coderdtest . New ( t , & coderdtest . Options {
2023-03-07 15:10:01 -06:00
DeploymentValues : dc ,
2023-02-07 01:58:21 +11:00
})
first := coderdtest . CreateFirstUser ( t , client )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
// With a user account.
2023-02-08 14:10:08 -06:00
const password = "SomeSecurePassword!"
2024-08-23 16:23:51 -05:00
user , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
Email : "test+user-@coder.com" ,
Username : "user" ,
Password : password ,
OrganizationIDs : [] uuid . UUID { first . OrganizationID },
2023-02-07 01:58:21 +11:00
})
require . NoError ( t , err )
2024-03-15 11:24:38 -05:00
dc . DisablePasswordAuth = serpent . Bool ( true )
2023-02-14 08:58:12 -06:00
2023-02-07 01:58:21 +11:00
userClient := codersdk . New ( client . URL )
_ , err = userClient . LoginWithPassword ( ctx , codersdk . LoginWithPasswordRequest {
Email : user . Email ,
Password : password ,
})
require . Error ( t , err )
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
require . Equal ( t , http . StatusForbidden , apiErr . StatusCode ())
require . Contains ( t , apiErr . Message , "Password authentication is disabled" )
})
2022-02-05 18:24:51 -06:00
t . Run ( "Success" , func ( t * testing . T ) {
t . Parallel ()
2023-02-06 15:12:50 -05:00
auditor := audit . NewMock ()
client := coderdtest . New ( t , & coderdtest . Options { Auditor : auditor })
2023-03-30 12:13:03 -05:00
numLogs := len ( auditor . AuditLogs ())
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2022-03-22 13:17:50 -06:00
req := 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-03-07 11:40:54 -06:00
}
2022-08-09 20:17:00 +03:00
_ , err := client . CreateFirstUser ( ctx , req )
2022-03-07 11:40:54 -06:00
require . NoError ( t , err )
2023-02-06 15:12:50 -05:00
numLogs ++ // add an audit log for create user
numLogs ++ // add an audit log for login
2022-09-26 22:51:58 -05:00
2022-08-09 20:17:00 +03:00
_ , err = client . LoginWithPassword ( ctx , codersdk . LoginWithPasswordRequest {
2022-03-07 11:40:54 -06:00
Email : req . Email ,
Password : req . Password ,
2022-01-22 23:58:10 -06:00
})
require . NoError ( t , err )
2022-09-26 22:51:58 -05:00
// Login should be case insensitive
_ , err = client . LoginWithPassword ( ctx , codersdk . LoginWithPasswordRequest {
Email : strings . ToUpper ( req . Email ),
Password : req . Password ,
})
require . NoError ( t , err )
2023-02-06 15:12:50 -05:00
2023-03-30 12:13:03 -05:00
require . Len ( t , auditor . AuditLogs (), numLogs )
require . Equal ( t , database . AuditActionLogin , auditor . AuditLogs ()[ numLogs - 1 ]. Action )
2022-01-22 23:58:10 -06:00
})
2022-06-01 14:58:55 -05:00
t . Run ( "Lifetime&Expire" , func ( t * testing . T ) {
t . Parallel ()
2022-08-09 20:17:00 +03:00
2022-06-27 13:50:52 -05:00
client := coderdtest . New ( t , nil )
2023-10-10 11:14:20 +01:00
owner := coderdtest . CreateFirstUser ( t , client )
2022-06-01 14:58:55 -05:00
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2022-11-09 15:31:24 +02:00
split := strings . Split ( client . SessionToken (), "-" )
2023-10-10 11:14:20 +01:00
key , err := client . APIKeyByID ( ctx , owner . UserID . String (), split [ 0 ])
2022-06-01 14:58:55 -05:00
require . NoError ( t , err , "fetch login key" )
2022-06-27 13:50:52 -05:00
require . Equal ( t , int64 ( 86400 ), key . LifetimeSeconds , "default should be 86400" )
2022-06-01 14:58:55 -05:00
2022-10-06 15:02:27 -04:00
// tokens have a longer life
2022-10-15 02:46:38 +10:00
token , err := client . CreateToken ( ctx , codersdk . Me , codersdk . CreateTokenRequest {})
2022-10-06 15:02:27 -04:00
require . NoError ( t , err , "make new token api key" )
2022-06-01 14:58:55 -05:00
split = strings . Split ( token . Key , "-" )
2023-10-10 11:14:20 +01:00
apiKey , err := client . APIKeyByID ( ctx , owner . UserID . String (), split [ 0 ])
2022-06-01 14:58:55 -05:00
require . NoError ( t , err , "fetch api key" )
2026-03-06 09:14:11 +00:00
require . True ( t , apiKey . ExpiresAt . After ( dbtime . Now (). Add ( time . Hour * 24 * 6 )), "default tokens lasts more than 6 days" )
require . True ( t , apiKey . ExpiresAt . Before ( dbtime . Now (). Add ( time . Hour * 24 * 8 )), "default tokens lasts less than 8 days" )
2022-10-06 15:02:27 -04:00
require . Greater ( t , apiKey . LifetimeSeconds , key . LifetimeSeconds , "token should have longer lifetime" )
2022-06-01 14:58:55 -05:00
})
2022-01-20 07:46:51 -06:00
}
2022-01-24 17:09:39 -08:00
2022-09-12 18:24:20 -05:00
func TestDeleteUser ( t * testing . T ) {
t . Parallel ()
t . Run ( "Works" , func ( t * testing . T ) {
t . Parallel ()
2023-03-21 09:10:22 -05:00
client , _ , api := coderdtest . NewWithAPI ( t , nil )
user := coderdtest . CreateFirstUser ( t , client )
authz := coderdtest . AssertRBAC ( t , api , client )
2023-04-24 21:48:26 +01:00
anotherClient , another := coderdtest . CreateAnotherUser ( t , client , user . OrganizationID )
2023-03-21 09:10:22 -05:00
err := client . DeleteUser ( context . Background (), another . ID )
2022-09-12 18:24:20 -05:00
require . NoError ( t , err )
// Attempt to create a user with the same email and username, and delete them again.
2024-08-23 16:23:51 -05:00
another , err = client . CreateUserWithOrgs ( context . Background (), codersdk . CreateUserRequestWithOrgs {
Email : another . Email ,
Username : another . Username ,
Password : "SomeSecurePassword!" ,
OrganizationIDs : [] uuid . UUID { user . OrganizationID },
2022-09-12 18:24:20 -05:00
})
require . NoError ( t , err )
2023-03-21 09:10:22 -05:00
err = client . DeleteUser ( context . Background (), another . ID )
2022-09-12 18:24:20 -05:00
require . NoError ( t , err )
2023-03-21 09:10:22 -05:00
2023-04-24 21:48:26 +01:00
// IMPORTANT: assert that the deleted user's session is no longer valid.
_ , err = anotherClient . User ( context . Background (), codersdk . Me )
require . Error ( t , err )
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
require . Equal ( t , http . StatusUnauthorized , apiErr . StatusCode ())
2023-03-21 09:10:22 -05:00
// RBAC checks
2024-05-15 09:46:35 -05:00
authz . AssertChecked ( t , policy . ActionCreate , rbac . ResourceUser )
authz . AssertChecked ( t , policy . ActionDelete , another )
2022-09-12 18:24:20 -05:00
})
t . Run ( "NoPermission" , func ( t * testing . T ) {
t . Parallel ()
api := coderdtest . New ( t , nil )
firstUser := coderdtest . CreateFirstUser ( t , api )
2023-02-06 17:48:21 -06:00
client , _ := coderdtest . CreateAnotherUser ( t , api , firstUser . OrganizationID )
2022-09-12 18:24:20 -05:00
err := client . DeleteUser ( context . Background (), firstUser . UserID )
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
2026-02-13 08:19:07 -06:00
require . Equal ( t , http . StatusNotFound , apiErr . StatusCode ())
2022-09-12 18:24:20 -05:00
})
t . Run ( "HasWorkspaces" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . NewWithProvisionerCloser ( t , nil )
user := coderdtest . CreateFirstUser ( t , client )
2023-02-06 17:48:21 -06:00
anotherClient , another := coderdtest . CreateAnotherUser ( t , client , user . OrganizationID )
2022-09-12 18:24:20 -05:00
version := coderdtest . CreateTemplateVersion ( t , client , user . OrganizationID , nil )
2023-10-03 11:02:56 -06:00
coderdtest . AwaitTemplateVersionJobCompleted ( t , client , version . ID )
2022-09-12 18:24:20 -05:00
template := coderdtest . CreateTemplate ( t , client , user . OrganizationID , version . ID )
2024-07-30 10:44:02 -06:00
coderdtest . CreateWorkspace ( t , anotherClient , template . ID )
2022-09-12 18:24:20 -05:00
err := client . DeleteUser ( context . Background (), another . ID )
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
require . Equal ( t , http . StatusExpectationFailed , apiErr . StatusCode ())
})
2023-02-22 16:48:16 +00:00
t . Run ( "Self" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
user := coderdtest . CreateFirstUser ( t , client )
err := client . DeleteUser ( context . Background (), user . UserID )
var apiErr * codersdk . Error
require . Error ( t , err , "should not be able to delete self" )
require . ErrorAs ( t , err , & apiErr , "should be a coderd error" )
require . Equal ( t , http . StatusForbidden , apiErr . StatusCode (), "should be forbidden" )
})
2025-08-07 16:31:27 +10:00
t . Run ( "CountCheckIncludesAllWorkspaces" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . NewWithProvisionerCloser ( t , nil )
firstUser := coderdtest . CreateFirstUser ( t , client )
// Create a target user who will own a workspace
targetUserClient , targetUser := coderdtest . CreateAnotherUser ( t , client , firstUser . OrganizationID )
// Create a User Admin who should not have permission to see the target user's workspace
userAdminClient , userAdmin := coderdtest . CreateAnotherUser ( t , client , firstUser . OrganizationID )
// Grant User Admin role to the userAdmin
userAdmin , err := client . UpdateUserRoles ( context . Background (), userAdmin . ID . String (), codersdk . UpdateRoles {
Roles : [] string { rbac . RoleUserAdmin (). String ()},
})
require . NoError ( t , err )
// Create a template and workspace owned by the target user
version := coderdtest . CreateTemplateVersion ( t , client , firstUser . OrganizationID , nil )
coderdtest . AwaitTemplateVersionJobCompleted ( t , client , version . ID )
template := coderdtest . CreateTemplate ( t , client , firstUser . OrganizationID , version . ID )
_ = coderdtest . CreateWorkspace ( t , targetUserClient , template . ID )
workspaces , err := userAdminClient . Workspaces ( context . Background (), codersdk . WorkspaceFilter {
Owner : targetUser . Username ,
})
require . NoError ( t , err )
require . Len ( t , workspaces . Workspaces , 0 )
// Attempt to delete the target user - this should fail because the
// user has a workspace not visible to the deleting user.
err = userAdminClient . DeleteUser ( context . Background (), targetUser . ID )
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
require . Equal ( t , http . StatusExpectationFailed , apiErr . StatusCode ())
require . Contains ( t , apiErr . Message , "has workspaces" )
})
2022-09-12 18:24:20 -05:00
}
2024-08-22 13:52:25 +02:00
func TestNotifyUserStatusChanged ( t * testing . T ) {
t . Parallel ()
type expectedNotification struct {
TemplateID uuid . UUID
UserID uuid . UUID
}
2024-11-12 12:40:46 +00:00
verifyNotificationDispatched := func ( notifyEnq * notificationstest . FakeEnqueuer , expectedNotifications [] expectedNotification , member codersdk . User , label string ) {
require . Equal ( t , len ( expectedNotifications ), len ( notifyEnq . Sent ()))
2024-08-22 13:52:25 +02:00
2024-11-12 12:40:46 +00:00
// Validate that each expected notification is present in notifyEnq.Sent()
2024-08-22 13:52:25 +02:00
for _ , expected := range expectedNotifications {
found := false
2025-01-30 17:44:04 +00:00
for _ , sent := range notifyEnq . Sent ( notificationstest . WithTemplateID ( expected . TemplateID )) {
2024-08-22 13:52:25 +02:00
if sent . TemplateID == expected . TemplateID &&
sent . UserID == expected . UserID &&
slices . Contains ( sent . Targets , member . ID ) &&
sent . Labels [ label ] == member . Username {
found = true
2025-01-30 17:44:04 +00:00
require . IsType ( t , map [ string ] any {}, sent . Data [ "user" ])
userData := sent . Data [ "user" ].( map [ string ] any )
require . Equal ( t , member . ID , userData [ "id" ])
require . Equal ( t , member . Name , userData [ "name" ])
require . Equal ( t , member . Email , userData [ "email" ])
2024-08-22 13:52:25 +02:00
break
}
}
require . True ( t , found , "Expected notification not found: %+v" , expected )
}
}
t . Run ( "Account suspended" , func ( t * testing . T ) {
t . Parallel ()
2024-11-12 12:40:46 +00:00
notifyEnq := & notificationstest . FakeEnqueuer {}
2024-08-22 13:52:25 +02:00
adminClient := coderdtest . New ( t , & coderdtest . Options {
NotificationsEnqueuer : notifyEnq ,
})
firstUser := coderdtest . CreateFirstUser ( t , adminClient )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
_ , userAdmin := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID , rbac . RoleUserAdmin ())
2024-08-23 16:23:51 -05:00
member , err := adminClient . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
OrganizationIDs : [] uuid . UUID { firstUser . OrganizationID },
Email : "another@user.org" ,
Username : "someone-else" ,
Password : "SomeSecurePassword!" ,
2024-08-22 13:52:25 +02:00
})
require . NoError ( t , err )
notifyEnq . Clear ()
// when
_ , err = adminClient . UpdateUserStatus ( context . Background (), member . Username , codersdk . UserStatusSuspended )
require . NoError ( t , err )
// then
verifyNotificationDispatched ( notifyEnq , [] expectedNotification {
{ TemplateID : notifications . TemplateUserAccountSuspended , UserID : firstUser . UserID },
{ TemplateID : notifications . TemplateUserAccountSuspended , UserID : userAdmin . ID },
{ TemplateID : notifications . TemplateYourAccountSuspended , UserID : member . ID },
}, member , "suspended_account_name" )
})
t . Run ( "Account reactivated" , func ( t * testing . T ) {
t . Parallel ()
// given
2024-11-12 12:40:46 +00:00
notifyEnq := & notificationstest . FakeEnqueuer {}
2024-08-22 13:52:25 +02:00
adminClient := coderdtest . New ( t , & coderdtest . Options {
NotificationsEnqueuer : notifyEnq ,
})
firstUser := coderdtest . CreateFirstUser ( t , adminClient )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
_ , userAdmin := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID , rbac . RoleUserAdmin ())
2024-08-23 16:23:51 -05:00
member , err := adminClient . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
OrganizationIDs : [] uuid . UUID { firstUser . OrganizationID },
Email : "another@user.org" ,
Username : "someone-else" ,
Password : "SomeSecurePassword!" ,
2024-08-22 13:52:25 +02:00
})
require . NoError ( t , err )
_ , err = adminClient . UpdateUserStatus ( context . Background (), member . Username , codersdk . UserStatusSuspended )
require . NoError ( t , err )
notifyEnq . Clear ()
// when
_ , err = adminClient . UpdateUserStatus ( context . Background (), member . Username , codersdk . UserStatusActive )
require . NoError ( t , err )
// then
verifyNotificationDispatched ( notifyEnq , [] expectedNotification {
{ TemplateID : notifications . TemplateUserAccountActivated , UserID : firstUser . UserID },
{ TemplateID : notifications . TemplateUserAccountActivated , UserID : userAdmin . ID },
{ TemplateID : notifications . TemplateYourAccountActivated , UserID : member . ID },
}, member , "activated_account_name" )
})
}
2024-08-02 14:56:54 +02:00
func TestNotifyDeletedUser ( t * testing . T ) {
t . Parallel ()
t . Run ( "OwnerNotified" , func ( t * testing . T ) {
t . Parallel ()
// given
2024-11-12 12:40:46 +00:00
notifyEnq := & notificationstest . FakeEnqueuer {}
2024-08-02 14:56:54 +02:00
adminClient := coderdtest . New ( t , & coderdtest . Options {
NotificationsEnqueuer : notifyEnq ,
})
2024-10-10 00:31:12 +02:00
firstUserResponse := coderdtest . CreateFirstUser ( t , adminClient )
2024-08-02 14:56:54 +02:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2024-10-10 00:31:12 +02:00
firstUser , err := adminClient . User ( ctx , firstUserResponse . UserID . String ())
require . NoError ( t , err )
2024-08-23 16:23:51 -05:00
user , err := adminClient . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
2024-10-10 00:31:12 +02:00
OrganizationIDs : [] uuid . UUID { firstUserResponse . OrganizationID },
2024-08-23 16:23:51 -05:00
Email : "another@user.org" ,
Username : "someone-else" ,
Password : "SomeSecurePassword!" ,
2024-08-02 14:56:54 +02:00
})
require . NoError ( t , err )
// when
err = adminClient . DeleteUser ( context . Background (), user . ID )
require . NoError ( t , err )
// then
2024-11-12 12:40:46 +00:00
require . Len ( t , notifyEnq . Sent (), 2 )
// notifyEnq.Sent()[0] is create account event
require . Equal ( t , notifications . TemplateUserAccountDeleted , notifyEnq . Sent ()[ 1 ]. TemplateID )
require . Equal ( t , firstUser . ID , notifyEnq . Sent ()[ 1 ]. UserID )
require . Contains ( t , notifyEnq . Sent ()[ 1 ]. Targets , user . ID )
require . Equal ( t , user . Username , notifyEnq . Sent ()[ 1 ]. Labels [ "deleted_account_name" ])
require . Equal ( t , user . Name , notifyEnq . Sent ()[ 1 ]. Labels [ "deleted_account_user_name" ])
require . Equal ( t , firstUser . Name , notifyEnq . Sent ()[ 1 ]. Labels [ "initiator" ])
2026-08-11 18:16:25 +05:00
require . Equal ( t , "user" , notifyEnq . Sent ()[ 1 ]. Labels [ "account_type" ])
2024-08-02 14:56:54 +02:00
})
t . Run ( "UserAdminNotified" , func ( t * testing . T ) {
t . Parallel ()
// given
2024-11-12 12:40:46 +00:00
notifyEnq := & notificationstest . FakeEnqueuer {}
2024-08-02 14:56:54 +02:00
adminClient := coderdtest . New ( t , & coderdtest . Options {
NotificationsEnqueuer : notifyEnq ,
})
firstUser := coderdtest . CreateFirstUser ( t , adminClient )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
_ , userAdmin := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID , rbac . RoleUserAdmin ())
2024-08-23 16:23:51 -05:00
member , err := adminClient . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
OrganizationIDs : [] uuid . UUID { firstUser . OrganizationID },
Email : "another@user.org" ,
Username : "someone-else" ,
Password : "SomeSecurePassword!" ,
2024-08-02 14:56:54 +02:00
})
require . NoError ( t , err )
// when
err = adminClient . DeleteUser ( context . Background (), member . ID )
require . NoError ( t , err )
// then
2024-11-12 12:40:46 +00:00
sent := notifyEnq . Sent ()
require . Len ( t , sent , 5 )
2025-11-11 21:23:23 -05:00
// Other notifications:
// "User admin" account created, "owner" notified
// "Member" account created, "owner" notified
// "Member" account created, "user admin" notified
2024-08-02 14:56:54 +02:00
// "Member" account deleted, "owner" notified
2025-11-11 21:23:23 -05:00
ownerNotifications := notifyEnq . Sent ( func ( n * notificationstest . FakeNotification ) bool {
return n . TemplateID == notifications . TemplateUserAccountDeleted &&
n . UserID == firstUser . UserID &&
slices . Contains ( n . Targets , member . ID ) &&
n . Labels [ "deleted_account_name" ] == member . Username
})
require . Len ( t , ownerNotifications , 1 )
2024-08-02 14:56:54 +02:00
// "Member" account deleted, "user admin" notified
2025-11-11 21:23:23 -05:00
adminNotifications := notifyEnq . Sent ( func ( n * notificationstest . FakeNotification ) bool {
return n . TemplateID == notifications . TemplateUserAccountDeleted &&
n . UserID == userAdmin . ID &&
slices . Contains ( n . Targets , member . ID ) &&
n . Labels [ "deleted_account_name" ] == member . Username
})
require . Len ( t , adminNotifications , 1 )
2024-08-02 14:56:54 +02:00
})
}
2022-02-05 18:24:51 -06:00
func TestPostLogout ( t * testing . T ) {
2022-01-24 17:09:39 -08:00
t . Parallel ()
2022-05-27 16:47:03 -04:00
// Checks that the cookie is cleared and the API Key is deleted from the database.
t . Run ( "Logout" , func ( t * testing . T ) {
2022-01-24 17:09:39 -08:00
t . Parallel ()
2023-02-06 15:12:50 -05:00
auditor := audit . NewMock ()
client := coderdtest . New ( t , & coderdtest . Options { Auditor : auditor })
2023-03-30 12:13:03 -05:00
numLogs := len ( auditor . AuditLogs ())
2022-01-24 17:09:39 -08:00
2023-10-10 11:14:20 +01:00
owner := coderdtest . CreateFirstUser ( t , client )
2023-02-06 15:12:50 -05:00
numLogs ++ // add an audit log for login
2022-05-27 16:47:03 -04:00
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2022-11-09 15:31:24 +02:00
keyID := strings . Split ( client . SessionToken (), "-" )[ 0 ]
2023-10-10 11:14:20 +01:00
apiKey , err := client . APIKeyByID ( ctx , owner . UserID . String (), keyID )
2022-05-27 16:47:03 -04:00
require . NoError ( t , err )
require . Equal ( t , keyID , apiKey . ID , "API key should exist in the database" )
2022-03-07 11:40:54 -06:00
fullURL , err := client . URL . Parse ( "/api/v2/users/logout" )
2022-01-24 17:09:39 -08:00
require . NoError ( t , err , "Server URL should parse successfully" )
2022-05-27 16:47:03 -04:00
res , err := client . Request ( ctx , http . MethodPost , fullURL . String (), nil )
2023-02-06 15:12:50 -05:00
numLogs ++ // add an audit log for logout
2022-01-24 17:09:39 -08:00
require . NoError ( t , err , "/logout request should succeed" )
2022-05-27 16:47:03 -04:00
res . Body . Close ()
require . Equal ( t , http . StatusOK , res . StatusCode )
2022-01-24 17:09:39 -08:00
2023-03-30 12:13:03 -05:00
require . Len ( t , auditor . AuditLogs (), numLogs )
require . Equal ( t , database . AuditActionLogout , auditor . AuditLogs ()[ numLogs - 1 ]. Action )
2023-02-06 15:12:50 -05:00
2022-05-27 16:47:03 -04:00
cookies := res . Cookies ()
2022-01-24 17:09:39 -08:00
2022-09-13 15:26:46 -04:00
var found bool
for _ , cookie := range cookies {
2023-01-29 15:47:24 -06:00
if cookie . Name == codersdk . SessionTokenCookie {
require . Equal ( t , codersdk . SessionTokenCookie , cookie . Name , "Cookie should be the auth cookie" )
2022-09-13 15:26:46 -04:00
require . Equal ( t , - 1 , cookie . MaxAge , "Cookie should be set to delete" )
found = true
}
}
require . True ( t , found , "auth cookie should be returned" )
2022-05-27 16:47:03 -04:00
2023-10-10 11:14:20 +01:00
_ , err = client . APIKeyByID ( ctx , owner . UserID . String (), keyID )
2022-08-09 20:17:00 +03:00
sdkErr := & codersdk . Error {}
2022-06-27 13:50:52 -05:00
require . ErrorAs ( t , err , & sdkErr )
require . Equal ( t , http . StatusUnauthorized , sdkErr . StatusCode (), "Expecting 401" )
2022-01-24 17:09:39 -08:00
})
}
2022-03-07 11:40:54 -06:00
2023-08-25 14:34:07 -05:00
// nolint:bodyclose
2022-03-07 11:40:54 -06:00
func TestPostUsers ( t * testing . T ) {
t . Parallel ()
t . Run ( "NoAuth" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2024-08-23 16:23:51 -05:00
_ , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {})
2022-03-07 11:40:54 -06:00
require . Error ( t , err )
})
t . Run ( "Conflicting" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
coderdtest . CreateFirstUser ( t , client )
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
me , err := client . User ( ctx , codersdk . Me )
2022-03-07 11:40:54 -06:00
require . NoError ( t , err )
2024-08-23 16:23:51 -05:00
_ , err = client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
Email : me . Email ,
Username : me . Username ,
Password : "MySecurePassword!" ,
OrganizationIDs : [] uuid . UUID { uuid . New ()},
2022-03-07 11:40:54 -06:00
})
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
require . Equal ( t , http . StatusConflict , apiErr . StatusCode ())
})
t . Run ( "OrganizationNotFound" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
coderdtest . CreateFirstUser ( t , client )
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2024-08-23 16:23:51 -05:00
_ , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
OrganizationIDs : [] uuid . UUID { uuid . New ()},
Email : "another@user.org" ,
Username : "someone-else" ,
Password : "SomeSecurePassword!" ,
2022-03-07 11:40:54 -06:00
})
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
require . Equal ( t , http . StatusNotFound , apiErr . StatusCode ())
})
2023-05-18 20:54:45 -04:00
t . Run ( "Create" , func ( t * testing . T ) {
t . Parallel ()
auditor := audit . NewMock ()
client := coderdtest . New ( t , & coderdtest . Options { Auditor : auditor })
numLogs := len ( auditor . AuditLogs ())
firstUser := coderdtest . CreateFirstUser ( t , client )
numLogs ++ // add an audit log for user create
numLogs ++ // add an audit log for login
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2024-08-23 16:23:51 -05:00
user , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
OrganizationIDs : [] uuid . UUID { firstUser . OrganizationID },
Email : "another@user.org" ,
Username : "someone-else" ,
Password : "SomeSecurePassword!" ,
2022-03-07 11:40:54 -06:00
})
require . NoError ( t , err )
2022-09-10 11:07:45 -05:00
2024-10-31 17:55:42 -05:00
// User should default to dormant.
require . Equal ( t , codersdk . UserStatusDormant , user . Status )
require . Len ( t , auditor . AuditLogs (), numLogs )
require . Equal ( t , database . AuditActionCreate , auditor . AuditLogs ()[ numLogs - 1 ]. Action )
require . Equal ( t , database . AuditActionLogin , auditor . AuditLogs ()[ numLogs - 2 ]. Action )
require . Len ( t , user . OrganizationIDs , 1 )
assert . Equal ( t , firstUser . OrganizationID , user . OrganizationIDs [ 0 ])
})
t . Run ( "CreateWithStatus" , func ( t * testing . T ) {
t . Parallel ()
auditor := audit . NewMock ()
client := coderdtest . New ( t , & coderdtest . Options { Auditor : auditor })
numLogs := len ( auditor . AuditLogs ())
firstUser := coderdtest . CreateFirstUser ( t , client )
numLogs ++ // add an audit log for user create
numLogs ++ // add an audit log for login
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
user , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
OrganizationIDs : [] uuid . UUID { firstUser . OrganizationID },
Email : "another@user.org" ,
Username : "someone-else" ,
Password : "SomeSecurePassword!" ,
2026-08-26 11:57:56 -06:00
UserStatus : new ( codersdk . UserStatusActive ),
2024-10-31 17:55:42 -05:00
})
require . NoError ( t , err )
require . Equal ( t , codersdk . UserStatusActive , user . Status )
2023-03-30 12:13:03 -05:00
require . Len ( t , auditor . AuditLogs (), numLogs )
require . Equal ( t , database . AuditActionCreate , auditor . AuditLogs ()[ numLogs - 1 ]. Action )
require . Equal ( t , database . AuditActionLogin , auditor . AuditLogs ()[ numLogs - 2 ]. Action )
2023-05-18 20:54:45 -04:00
require . Len ( t , user . OrganizationIDs , 1 )
assert . Equal ( t , firstUser . OrganizationID , user . OrganizationIDs [ 0 ])
2022-03-07 11:40:54 -06:00
})
2023-02-07 01:58:21 +11:00
t . Run ( "LastSeenAt" , func ( t * testing . T ) {
t . Parallel ()
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
client := coderdtest . New ( t , nil )
firstUserResp := coderdtest . CreateFirstUser ( t , client )
firstUser , err := client . User ( ctx , firstUserResp . UserID . String ())
require . NoError ( t , err )
2023-02-06 17:48:21 -06:00
_ , _ = coderdtest . CreateAnotherUser ( t , client , firstUserResp . OrganizationID )
2023-02-07 01:58:21 +11:00
allUsersRes , err := client . Users ( ctx , codersdk . UsersRequest {})
require . NoError ( t , err )
require . Len ( t , allUsersRes . Users , 2 )
// We sent the "GET Users" request with the first user, but the second user
// should be Never since they haven't performed a request.
for _ , user := range allUsersRes . Users {
if user . ID == firstUser . ID {
2023-09-01 19:50:12 +03:00
require . WithinDuration ( t , firstUser . LastSeenAt , dbtime . Now (), testutil . WaitShort )
2023-02-07 01:58:21 +11:00
} else {
require . Zero ( t , user . LastSeenAt )
}
}
})
2023-08-10 20:04:35 -05:00
t . Run ( "CreateNoneLoginType" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
first := coderdtest . CreateFirstUser ( t , client )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2026-07-28 21:05:50 +10:00
_ , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
2024-08-23 16:23:51 -05:00
OrganizationIDs : [] uuid . UUID { first . OrganizationID },
Email : "another@user.org" ,
Username : "someone-else" ,
Password : "" ,
UserLoginType : codersdk . LoginTypeNone ,
2023-08-10 20:04:35 -05:00
})
2026-07-28 21:05:50 +10:00
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
require . Equal ( t , http . StatusBadRequest , apiErr . StatusCode ())
require . Contains ( t , apiErr . Message , "service account" )
2023-08-10 20:04:35 -05:00
})
t . Run ( "CreateOIDCLoginType" , func ( t * testing . T ) {
t . Parallel ()
email := "another@user.org"
2023-08-25 14:34:07 -05:00
fake := oidctest . NewFakeIDP ( t ,
oidctest . WithServing (),
)
cfg := fake . OIDCConfig ( t , nil , func ( cfg * coderd . OIDCConfig ) {
cfg . AllowSignups = true
2023-08-10 20:04:35 -05:00
})
client := coderdtest . New ( t , & coderdtest . Options {
2023-08-25 14:34:07 -05:00
OIDCConfig : cfg ,
2023-08-10 20:04:35 -05:00
})
first := coderdtest . CreateFirstUser ( t , client )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2024-08-23 16:23:51 -05:00
_ , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
OrganizationIDs : [] uuid . UUID { first . OrganizationID },
Email : email ,
Username : "someone-else" ,
Password : "" ,
UserLoginType : codersdk . LoginTypeOIDC ,
2023-08-10 20:04:35 -05:00
})
require . NoError ( t , err )
// Try to log in with OIDC.
2023-08-25 14:34:07 -05:00
userClient , _ := fake . Login ( t , client , jwt . MapClaims {
2026-06-04 14:37:19 -04:00
"email" : email ,
"email_verified" : true ,
"sub" : uuid . NewString (),
2023-08-25 14:34:07 -05:00
})
2023-08-10 20:04:35 -05:00
found , err := userClient . User ( ctx , "me" )
require . NoError ( t , err )
require . Equal ( t , found . LoginType , codersdk . LoginTypeOIDC )
})
2026-03-11 10:19:08 -07:00
2026-04-07 14:25:32 -04:00
t . Run ( "ServiceAccount/Unlicensed" , func ( t * testing . T ) {
2026-03-11 10:19:08 -07:00
t . Parallel ()
client := coderdtest . New ( t , nil )
first := coderdtest . CreateFirstUser ( t , client )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2026-04-07 14:25:32 -04:00
_ , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
2026-03-11 10:19:08 -07:00
OrganizationIDs : [] uuid . UUID { first . OrganizationID },
Username : "service-acct-ok" ,
UserLoginType : codersdk . LoginTypeNone ,
ServiceAccount : true ,
})
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
2026-04-07 14:25:32 -04:00
require . Equal ( t , http . StatusForbidden , apiErr . StatusCode ())
require . Contains ( t , apiErr . Message , "Premium feature" )
2026-03-11 10:19:08 -07:00
})
t . Run ( "NonServiceAccount/WithoutEmail" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
first := coderdtest . CreateFirstUser ( t , client )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
_ , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
OrganizationIDs : [] uuid . UUID { first . OrganizationID },
Username : "regular-no-email" ,
UserLoginType : codersdk . LoginTypePassword ,
})
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
require . Equal ( t , http . StatusBadRequest , apiErr . StatusCode ())
})
2022-03-07 11:40:54 -06:00
}
2024-07-30 15:37:45 +02:00
func TestNotifyCreatedUser ( t * testing . T ) {
t . Parallel ()
t . Run ( "OwnerNotified" , func ( t * testing . T ) {
t . Parallel ()
// given
2024-11-12 12:40:46 +00:00
notifyEnq := & notificationstest . FakeEnqueuer {}
2024-07-30 15:37:45 +02:00
adminClient := coderdtest . New ( t , & coderdtest . Options {
NotificationsEnqueuer : notifyEnq ,
})
firstUser := coderdtest . CreateFirstUser ( t , adminClient )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
// when
2024-08-23 16:23:51 -05:00
user , err := adminClient . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
OrganizationIDs : [] uuid . UUID { firstUser . OrganizationID },
Email : "another@user.org" ,
Username : "someone-else" ,
Password : "SomeSecurePassword!" ,
2024-07-30 15:37:45 +02:00
})
require . NoError ( t , err )
// then
2025-01-30 17:44:04 +00:00
sent := notifyEnq . Sent ( notificationstest . WithTemplateID ( notifications . TemplateUserAccountCreated ))
require . Len ( t , sent , 1 )
require . Equal ( t , notifications . TemplateUserAccountCreated , sent [ 0 ]. TemplateID )
require . Equal ( t , firstUser . UserID , sent [ 0 ]. UserID )
require . Contains ( t , sent [ 0 ]. Targets , user . ID )
require . Equal ( t , user . Username , sent [ 0 ]. Labels [ "created_account_name" ])
2026-08-11 18:16:25 +05:00
require . Equal ( t , "user" , sent [ 0 ]. Labels [ "account_type" ])
2025-01-30 17:44:04 +00:00
require . IsType ( t , map [ string ] any {}, sent [ 0 ]. Data [ "user" ])
userData := sent [ 0 ]. Data [ "user" ].( map [ string ] any )
require . Equal ( t , user . ID , userData [ "id" ])
require . Equal ( t , user . Name , userData [ "name" ])
require . Equal ( t , user . Email , userData [ "email" ])
2024-07-30 15:37:45 +02:00
})
t . Run ( "UserAdminNotified" , func ( t * testing . T ) {
t . Parallel ()
// given
2024-11-12 12:40:46 +00:00
notifyEnq := & notificationstest . FakeEnqueuer {}
2024-07-30 15:37:45 +02:00
adminClient := coderdtest . New ( t , & coderdtest . Options {
NotificationsEnqueuer : notifyEnq ,
})
firstUser := coderdtest . CreateFirstUser ( t , adminClient )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2024-08-23 16:23:51 -05:00
userAdmin , err := adminClient . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
OrganizationIDs : [] uuid . UUID { firstUser . OrganizationID },
Email : "user-admin@user.org" ,
Username : "mr-user-admin" ,
Password : "SomeSecurePassword!" ,
2024-07-30 15:37:45 +02:00
})
require . NoError ( t , err )
_ , err = adminClient . UpdateUserRoles ( ctx , userAdmin . Username , codersdk . UpdateRoles {
Roles : [] string {
rbac . RoleUserAdmin (). String (),
},
})
require . NoError ( t , err )
// when
2024-08-23 16:23:51 -05:00
member , err := adminClient . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
OrganizationIDs : [] uuid . UUID { firstUser . OrganizationID },
Email : "another@user.org" ,
Username : "someone-else" ,
Password : "SomeSecurePassword!" ,
2024-07-30 15:37:45 +02:00
})
require . NoError ( t , err )
// then
2024-11-12 12:40:46 +00:00
sent := notifyEnq . Sent ()
require . Len ( t , sent , 3 )
2024-07-30 15:37:45 +02:00
// "User admin" account created, "owner" notified
2025-11-11 21:23:23 -05:00
ownerNotifiedAboutUserAdmin := notifyEnq . Sent ( func ( n * notificationstest . FakeNotification ) bool {
return n . TemplateID == notifications . TemplateUserAccountCreated &&
n . UserID == firstUser . UserID &&
slices . Contains ( n . Targets , userAdmin . ID ) &&
n . Labels [ "created_account_name" ] == userAdmin . Username
})
require . Len ( t , ownerNotifiedAboutUserAdmin , 1 )
2024-07-30 15:37:45 +02:00
// "Member" account created, "owner" notified
2025-11-11 21:23:23 -05:00
ownerNotifiedAboutMember := notifyEnq . Sent ( func ( n * notificationstest . FakeNotification ) bool {
return n . TemplateID == notifications . TemplateUserAccountCreated &&
n . UserID == firstUser . UserID &&
slices . Contains ( n . Targets , member . ID ) &&
n . Labels [ "created_account_name" ] == member . Username
})
require . Len ( t , ownerNotifiedAboutMember , 1 )
2024-07-30 15:37:45 +02:00
// "Member" account created, "user admin" notified
2025-11-11 21:23:23 -05:00
userAdminNotifiedAboutMember := notifyEnq . Sent ( func ( n * notificationstest . FakeNotification ) bool {
return n . TemplateID == notifications . TemplateUserAccountCreated &&
n . UserID == userAdmin . ID &&
slices . Contains ( n . Targets , member . ID ) &&
n . Labels [ "created_account_name" ] == member . Username
})
require . Len ( t , userAdminNotifiedAboutMember , 1 )
2024-07-30 15:37:45 +02:00
})
}
2022-04-12 11:05:21 -03:00
func TestUpdateUserProfile ( t * testing . T ) {
t . Parallel ()
t . Run ( "UserNotFound" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
coderdtest . CreateFirstUser ( t , client )
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
_ , err := client . UpdateUserProfile ( ctx , uuid . New (). String (), codersdk . UpdateUserProfileRequest {
2022-04-12 11:05:21 -03:00
Username : "newusername" ,
})
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
// Right now, we are raising a BAD request error because we don't support a
// user accessing other users info
2026-02-13 08:19:07 -06:00
require . Equal ( t , http . StatusNotFound , apiErr . StatusCode ())
2022-04-12 11:05:21 -03:00
})
t . Run ( "ConflictingUsername" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
user := coderdtest . CreateFirstUser ( t , client )
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2024-08-23 16:23:51 -05:00
existentUser , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
Email : "bruno@coder.com" ,
Username : "bruno" ,
Password : "SomeSecurePassword!" ,
OrganizationIDs : [] uuid . UUID { user . OrganizationID },
2022-04-12 11:05:21 -03:00
})
2022-04-23 17:58:57 -05:00
require . NoError ( t , err )
2022-08-09 20:17:00 +03:00
_ , err = client . UpdateUserProfile ( ctx , codersdk . Me , codersdk . UpdateUserProfileRequest {
2022-04-12 11:05:21 -03:00
Username : existentUser . Username ,
})
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
require . Equal ( t , http . StatusConflict , apiErr . StatusCode ())
})
2024-06-04 14:17:17 +01:00
t . Run ( "UpdateSelf" , func ( t * testing . T ) {
2022-04-12 11:05:21 -03:00
t . Parallel ()
2022-09-08 21:16:16 -05:00
auditor := audit . NewMock ()
client := coderdtest . New ( t , & coderdtest . Options { Auditor : auditor })
2023-03-30 12:13:03 -05:00
numLogs := len ( auditor . AuditLogs ())
2023-02-06 15:12:50 -05:00
2022-04-12 11:05:21 -03:00
coderdtest . CreateFirstUser ( t , client )
2023-02-06 15:12:50 -05:00
numLogs ++ // add an audit log for login
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2024-06-04 14:17:17 +01:00
me , err := client . User ( ctx , codersdk . Me )
2022-04-12 11:05:21 -03:00
require . NoError ( t , err )
2024-06-04 14:17:17 +01:00
userProfile , err := client . UpdateUserProfile ( ctx , codersdk . Me , codersdk . UpdateUserProfileRequest {
Username : me . Username + "1" ,
Name : me . Name + "1" ,
})
2023-02-06 15:12:50 -05:00
numLogs ++ // add an audit log for user update
2024-06-04 14:17:17 +01:00
require . NoError ( t , err )
require . Equal ( t , me . Username + "1" , userProfile . Username )
require . Equal ( t , me . Name + "1" , userProfile . Name )
require . Len ( t , auditor . AuditLogs (), numLogs )
require . Equal ( t , database . AuditActionWrite , auditor . AuditLogs ()[ numLogs - 1 ]. Action )
})
2025-10-02 15:07:49 +02:00
t . Run ( "UpdateSelfAsMember_Name" , func ( t * testing . T ) {
2024-06-04 14:17:17 +01:00
t . Parallel ()
auditor := audit . NewMock ()
client := coderdtest . New ( t , & coderdtest . Options { Auditor : auditor })
numLogs := len ( auditor . AuditLogs ())
firstUser := coderdtest . CreateFirstUser ( t , client )
numLogs ++ // add an audit log for login
2025-10-02 15:07:49 +02:00
memberClient , memberUser := coderdtest . CreateAnotherUser ( t , client , firstUser . OrganizationID )
numLogs ++ // add an audit log for user creation
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
newName := coderdtest . RandomName ( t )
userProfile , err := memberClient . UpdateUserProfile ( ctx , codersdk . Me , codersdk . UpdateUserProfileRequest {
Name : newName ,
Username : memberUser . Username ,
})
numLogs ++ // add an audit log for user update
numLogs ++ // add an audit log for API key creation
require . NoError ( t , err )
require . Equal ( t , memberUser . Username , userProfile . Username )
require . Equal ( t , newName , userProfile . Name )
require . Len ( t , auditor . AuditLogs (), numLogs )
require . Equal ( t , database . AuditActionWrite , auditor . AuditLogs ()[ numLogs - 1 ]. Action )
})
t . Run ( "UpdateSelfAsMember_Username" , func ( t * testing . T ) {
t . Parallel ()
auditor := audit . NewMock ()
client := coderdtest . New ( t , & coderdtest . Options { Auditor : auditor })
firstUser := coderdtest . CreateFirstUser ( t , client )
memberClient , memberUser := coderdtest . CreateAnotherUser ( t , client , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
newUsername := coderdtest . RandomUsername ( t )
_ , err := memberClient . UpdateUserProfile ( ctx , codersdk . Me , codersdk . UpdateUserProfileRequest {
Name : memberUser . Name ,
Username : newUsername ,
})
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
require . Equal ( t , http . StatusNotFound , apiErr . StatusCode ())
})
t . Run ( "UpdateMemberAsAdmin_Username" , func ( t * testing . T ) {
t . Parallel ()
auditor := audit . NewMock ()
adminClient := coderdtest . New ( t , & coderdtest . Options { Auditor : auditor })
numLogs := len ( auditor . AuditLogs ())
adminUser := coderdtest . CreateFirstUser ( t , adminClient )
numLogs ++ // add an audit log for login
_ , memberUser := coderdtest . CreateAnotherUser ( t , adminClient , adminUser . OrganizationID )
2024-06-04 14:17:17 +01:00
numLogs ++ // add an audit log for user creation
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2024-12-16 17:59:44 +11:00
newUsername := coderdtest . RandomUsername ( t )
2025-10-02 15:07:49 +02:00
userProfile , err := adminClient . UpdateUserProfile ( ctx , codersdk . Me , codersdk . UpdateUserProfileRequest {
Name : memberUser . Name ,
2024-12-16 17:59:44 +11:00
Username : newUsername ,
2024-06-04 14:17:17 +01:00
})
2025-10-02 15:07:49 +02:00
2024-06-04 14:17:17 +01:00
numLogs ++ // add an audit log for user update
numLogs ++ // add an audit log for API key creation
require . NoError ( t , err )
2024-12-16 17:59:44 +11:00
require . Equal ( t , newUsername , userProfile . Username )
2025-10-02 15:07:49 +02:00
require . Equal ( t , memberUser . Name , userProfile . Name )
2024-06-04 14:17:17 +01:00
2023-03-30 12:13:03 -05:00
require . Len ( t , auditor . AuditLogs (), numLogs )
require . Equal ( t , database . AuditActionWrite , auditor . AuditLogs ()[ numLogs - 1 ]. Action )
2022-04-12 11:05:21 -03:00
})
2024-01-17 13:20:45 +01:00
t . Run ( "InvalidRealUserName" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
user := coderdtest . CreateFirstUser ( t , client )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2024-08-23 16:23:51 -05:00
_ , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
Email : "john@coder.com" ,
Username : "john" ,
Password : "SomeSecurePassword!" ,
OrganizationIDs : [] uuid . UUID { user . OrganizationID },
2024-01-17 13:20:45 +01:00
})
require . NoError ( t , err )
_ , err = client . UpdateUserProfile ( ctx , codersdk . Me , codersdk . UpdateUserProfileRequest {
Name : " Mr Bean" , // must not have leading space
})
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
require . Equal ( t , http . StatusBadRequest , apiErr . StatusCode ())
})
2026-06-26 16:35:03 -06:00
t . Run ( "UpdateAvatar" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
coderdtest . CreateFirstUser ( t , client )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
me , err := client . User ( ctx , codersdk . Me )
require . NoError ( t , err )
// The first user is a password user, so the avatar is editable.
const newAvatar = "/emojis/1f600.png"
userProfile , err := client . UpdateUserProfile ( ctx , codersdk . Me , codersdk . UpdateUserProfileRequest {
Username : me . Username ,
Name : me . Name ,
AvatarURL : newAvatar ,
})
require . NoError ( t , err )
require . Equal ( t , newAvatar , userProfile . AvatarURL )
})
t . Run ( "IgnoresAvatarForSSOUser" , func ( t * testing . T ) {
t . Parallel ()
client , db := coderdtest . NewWithDatabase ( t , nil )
// The first user is an owner and can update other users' profiles.
coderdtest . CreateFirstUser ( t , client )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
// Avatars for SSO users are synced from the identity provider on login,
// so a submitted avatar must be ignored and the existing one preserved.
ssoUser := dbgen . User ( t , db , database . User {
Email : "sso-avatar@coder.com" ,
Username : "sso-avatar" ,
LoginType : database . LoginTypeOIDC ,
})
// dbgen.User does not persist the avatar at creation, so set it directly
// to emulate an avatar synced from the identity provider.
const idpAvatar = "https://idp.example.com/avatar.png"
//nolint:gocritic // Test setup requires a system context to set the avatar.
ssoUser , err := db . UpdateUserProfile ( dbauthz . AsSystemRestricted ( ctx ), database . UpdateUserProfileParams {
ID : ssoUser . ID ,
Email : ssoUser . Email ,
Name : ssoUser . Name ,
AvatarURL : idpAvatar ,
Username : ssoUser . Username ,
UpdatedAt : dbtime . Now (),
})
require . NoError ( t , err )
userProfile , err := client . UpdateUserProfile ( ctx , ssoUser . ID . String (), codersdk . UpdateUserProfileRequest {
Username : ssoUser . Username ,
Name : ssoUser . Name ,
AvatarURL : "/emojis/1f600.png" ,
})
require . NoError ( t , err )
require . Equal ( t , idpAvatar , userProfile . AvatarURL )
})
2022-04-12 11:05:21 -03:00
}
2022-05-06 09:20:08 -05:00
func TestUpdateUserPassword ( t * testing . T ) {
t . Parallel ()
t . Run ( "MemberCantUpdateAdminPassword" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
2023-10-10 11:14:20 +01:00
owner := coderdtest . CreateFirstUser ( t , client )
member , _ := coderdtest . CreateAnotherUser ( t , client , owner . OrganizationID )
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2023-10-10 11:14:20 +01:00
err := member . UpdateUserPassword ( ctx , owner . UserID . String (), codersdk . UpdateUserPasswordRequest {
2022-05-06 09:20:08 -05:00
Password : "newpassword" ,
})
require . Error ( t , err , "member should not be able to update admin password" )
})
t . Run ( "AdminCanUpdateMemberPassword" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
2023-10-10 11:14:20 +01:00
owner := coderdtest . CreateFirstUser ( t , client )
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2024-08-23 16:23:51 -05:00
member , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
Email : "coder@coder.com" ,
Username : "coder" ,
Password : "SomeStrongPassword!" ,
OrganizationIDs : [] uuid . UUID { owner . OrganizationID },
2022-05-06 09:20:08 -05:00
})
require . NoError ( t , err , "create member" )
2022-08-09 20:17:00 +03:00
err = client . UpdateUserPassword ( ctx , member . ID . String (), codersdk . UpdateUserPasswordRequest {
2023-02-08 14:10:08 -06:00
Password : "SomeNewStrongPassword!" ,
2022-05-06 09:20:08 -05:00
})
require . NoError ( t , err , "admin should be able to update member password" )
// Check if the member can login using the new password
2022-08-09 20:17:00 +03:00
_ , err = client . LoginWithPassword ( ctx , codersdk . LoginWithPasswordRequest {
2022-05-06 09:20:08 -05:00
Email : "coder@coder.com" ,
2023-02-08 14:10:08 -06:00
Password : "SomeNewStrongPassword!" ,
2022-05-06 09:20:08 -05:00
})
require . NoError ( t , err , "member should login successfully with the new password" )
})
2024-07-09 14:28:39 -05:00
2026-07-07 09:05:14 -07:00
t . Run ( "UserAdminCanUpdateMemberPassword" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
owner := coderdtest . CreateFirstUser ( t , client )
userAdmin , _ := coderdtest . CreateAnotherUser ( t , client , owner . OrganizationID , rbac . RoleUserAdmin ())
memberClient , member := coderdtest . CreateAnotherUser ( t , client , owner . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
apikey1 , err := memberClient . CreateToken ( ctx , codersdk . Me , codersdk . CreateTokenRequest {})
require . NoError ( t , err )
apikey1ID , _ , ok := strings . Cut ( apikey1 . Key , "-" )
require . True ( t , ok )
apikey2 , err := memberClient . CreateToken ( ctx , codersdk . Me , codersdk . CreateTokenRequest {})
require . NoError ( t , err )
apikey2ID , _ , ok := strings . Cut ( apikey2 . Key , "-" )
require . True ( t , ok )
// Confirm the token IDs resolve before the reset, so later
// 404s prove password reset removed them.
_ , err = memberClient . APIKeyByID ( ctx , member . ID . String (), apikey1ID )
require . NoError ( t , err )
_ , err = memberClient . APIKeyByID ( ctx , member . ID . String (), apikey2ID )
require . NoError ( t , err )
err = userAdmin . UpdateUserPassword ( ctx , member . ID . String (), codersdk . UpdateUserPasswordRequest {
Password : "SomeNewStrongPassword!" ,
})
require . NoError ( t , err , "user-admin should be able to update member password" )
// The old session token was deleted with the password reset, so the
// member client is unauthorized before it logs back in.
_ , err = memberClient . APIKeyByID ( ctx , member . ID . String (), apikey1ID )
require . Error ( t , err )
cerr := coderdtest . SDKError ( t , err )
require . Equal ( t , http . StatusUnauthorized , cerr . StatusCode ())
resp , err := client . LoginWithPassword ( ctx , codersdk . LoginWithPasswordRequest {
Email : member . Email ,
Password : "SomeNewStrongPassword!" ,
})
require . NoError ( t , err , "member should login successfully with the new password" )
memberClient = codersdk . New (
memberClient . URL ,
codersdk . WithSessionToken ( resp . SessionToken ),
codersdk . WithHTTPClient ( coderdtest . NewIsolatedHTTPClient ( memberClient . URL )),
)
// After re-authentication, the old API keys should be gone from storage.
_ , err = memberClient . APIKeyByID ( ctx , member . ID . String (), apikey1ID )
require . Error ( t , err )
cerr = coderdtest . SDKError ( t , err )
require . Equal ( t , http . StatusNotFound , cerr . StatusCode ())
_ , err = memberClient . APIKeyByID ( ctx , member . ID . String (), apikey2ID )
require . Error ( t , err )
cerr = coderdtest . SDKError ( t , err )
require . Equal ( t , http . StatusNotFound , cerr . StatusCode ())
})
2024-10-24 22:48:15 +02:00
t . Run ( "AuditorCantUpdateOtherUserPassword" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
owner := coderdtest . CreateFirstUser ( t , client )
auditor , _ := coderdtest . CreateAnotherUser ( t , client , owner . OrganizationID , rbac . RoleAuditor ())
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
member , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
Email : "coder@coder.com" ,
Username : "coder" ,
Password : "SomeStrongPassword!" ,
OrganizationIDs : [] uuid . UUID { owner . OrganizationID },
})
require . NoError ( t , err , "create member" )
err = auditor . UpdateUserPassword ( ctx , member . ID . String (), codersdk . UpdateUserPasswordRequest {
Password : "SomeNewStrongPassword!" ,
})
require . Error ( t , err , "auditor should not be able to update member password" )
require . ErrorContains ( t , err , "unexpected status code 404: Resource not found or you do not have access to this resource" )
})
2022-05-27 12:29:55 -05:00
t . Run ( "MemberCanUpdateOwnPassword" , func ( t * testing . T ) {
t . Parallel ()
2022-09-08 21:16:16 -05:00
auditor := audit . NewMock ()
client := coderdtest . New ( t , & coderdtest . Options { Auditor : auditor })
2023-03-30 12:13:03 -05:00
numLogs := len ( auditor . AuditLogs ())
2023-02-06 15:12:50 -05:00
2023-10-10 11:14:20 +01:00
owner := coderdtest . CreateFirstUser ( t , client )
2023-02-06 15:12:50 -05:00
numLogs ++ // add an audit log for user create
numLogs ++ // add an audit log for login
2023-10-10 11:14:20 +01:00
member , _ := coderdtest . CreateAnotherUser ( t , client , owner . OrganizationID )
2023-02-06 15:12:50 -05:00
numLogs ++ // add an audit log for user create
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
err := member . UpdateUserPassword ( ctx , "me" , codersdk . UpdateUserPasswordRequest {
2023-02-08 14:10:08 -06:00
OldPassword : "SomeSecurePassword!" ,
Password : "MyNewSecurePassword!" ,
2022-05-27 12:29:55 -05:00
})
2023-02-06 15:12:50 -05:00
numLogs ++ // add an audit log for user update
2022-05-27 12:29:55 -05:00
require . NoError ( t , err , "member should be able to update own password" )
2023-02-06 15:12:50 -05:00
2023-03-30 12:13:03 -05:00
require . Len ( t , auditor . AuditLogs (), numLogs )
require . Equal ( t , database . AuditActionWrite , auditor . AuditLogs ()[ numLogs - 1 ]. Action )
2022-05-27 12:29:55 -05:00
})
2024-07-09 14:28:39 -05:00
2022-05-27 12:29:55 -05:00
t . Run ( "MemberCantUpdateOwnPasswordWithoutOldPassword" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
2023-10-10 11:14:20 +01:00
owner := coderdtest . CreateFirstUser ( t , client )
member , _ := coderdtest . CreateAnotherUser ( t , client , owner . OrganizationID )
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
err := member . UpdateUserPassword ( ctx , "me" , codersdk . UpdateUserPasswordRequest {
2022-05-27 12:29:55 -05:00
Password : "newpassword" ,
})
require . Error ( t , err , "member should not be able to update own password without providing old password" )
2024-10-24 22:48:15 +02:00
require . ErrorContains ( t , err , "Old password is required." )
2022-05-27 12:29:55 -05:00
})
2024-07-09 14:28:39 -05:00
t . Run ( "AuditorCantTellIfPasswordIncorrect" , func ( t * testing . T ) {
t . Parallel ()
auditor := audit . NewMock ()
adminClient := coderdtest . New ( t , & coderdtest . Options { Auditor : auditor })
adminUser := coderdtest . CreateFirstUser ( t , adminClient )
auditorClient , _ := coderdtest . CreateAnotherUser ( t , adminClient ,
adminUser . OrganizationID ,
rbac . RoleAuditor (),
)
_ , memberUser := coderdtest . CreateAnotherUser ( t , adminClient , adminUser . OrganizationID )
numLogs := len ( auditor . AuditLogs ())
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
err := auditorClient . UpdateUserPassword ( ctx , memberUser . ID . String (), codersdk . UpdateUserPasswordRequest {
Password : "MySecurePassword!" ,
})
numLogs ++ // add an audit log for user update
require . Error ( t , err , "auditors shouldn't be able to update passwords" )
var httpErr * codersdk . Error
require . True ( t , xerrors . As ( err , & httpErr ))
// ensure that the error we get is "not found" and not "bad request"
require . Equal ( t , http . StatusNotFound , httpErr . StatusCode ())
require . Len ( t , auditor . AuditLogs (), numLogs )
require . Equal ( t , database . AuditActionWrite , auditor . AuditLogs ()[ numLogs - 1 ]. Action )
require . Equal ( t , int32 ( http . StatusNotFound ), auditor . AuditLogs ()[ numLogs - 1 ]. StatusCode )
})
2024-10-24 22:48:15 +02:00
t . Run ( "AdminCantUpdateOwnPasswordWithoutOldPassword" , func ( t * testing . T ) {
2022-05-27 12:29:55 -05:00
t . Parallel ()
2022-09-08 21:16:16 -05:00
auditor := audit . NewMock ()
client := coderdtest . New ( t , & coderdtest . Options { Auditor : auditor })
2023-03-30 12:13:03 -05:00
numLogs := len ( auditor . AuditLogs ())
2023-02-06 15:12:50 -05:00
2022-05-27 12:29:55 -05:00
_ = coderdtest . CreateFirstUser ( t , client )
2023-02-06 15:12:50 -05:00
numLogs ++ // add an audit log for login
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
err := client . UpdateUserPassword ( ctx , "me" , codersdk . UpdateUserPasswordRequest {
2023-02-08 14:10:08 -06:00
Password : "MySecurePassword!" ,
2022-05-27 12:29:55 -05:00
})
2023-02-06 15:12:50 -05:00
numLogs ++ // add an audit log for user update
2024-10-24 22:48:15 +02:00
require . Error ( t , err , "admin should not be able to update own password without providing old password" )
require . ErrorContains ( t , err , "Old password is required." )
2023-02-06 15:12:50 -05:00
2023-03-30 12:13:03 -05:00
require . Len ( t , auditor . AuditLogs (), numLogs )
require . Equal ( t , database . AuditActionWrite , auditor . AuditLogs ()[ numLogs - 1 ]. Action )
2022-05-27 12:29:55 -05:00
})
2022-10-19 21:12:03 -05:00
2024-11-05 17:22:32 +01:00
t . Run ( "ValidateUserPassword" , func ( t * testing . T ) {
t . Parallel ()
auditor := audit . NewMock ()
client := coderdtest . New ( t , & coderdtest . Options { Auditor : auditor })
_ = coderdtest . CreateFirstUser ( t , client )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
resp , err := client . ValidateUserPassword ( ctx , codersdk . ValidateUserPasswordRequest {
Password : "MySecurePassword!" ,
})
require . NoError ( t , err , "users shoud be able to validate complexity of a potential new password" )
require . True ( t , resp . Valid )
})
2022-10-19 21:12:03 -05:00
t . Run ( "ChangingPasswordDeletesKeys" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
user := coderdtest . CreateFirstUser ( t , client )
2023-03-23 17:42:20 -05:00
ctx := testutil . Context ( t , testutil . WaitLong )
2022-10-19 21:12:03 -05:00
apikey1 , err := client . CreateToken ( ctx , user . UserID . String (), codersdk . CreateTokenRequest {})
require . NoError ( t , err )
apikey2 , err := client . CreateToken ( ctx , user . UserID . String (), codersdk . CreateTokenRequest {})
require . NoError ( t , err )
err = client . UpdateUserPassword ( ctx , "me" , codersdk . UpdateUserPasswordRequest {
2024-10-24 22:48:15 +02:00
OldPassword : "SomeSecurePassword!" ,
Password : "MyNewSecurePassword!" ,
2022-10-19 21:12:03 -05:00
})
require . NoError ( t , err )
// Trying to get an API key should fail since our client's token
// has been deleted.
2023-03-02 09:39:38 -08:00
_ , err = client . APIKeyByID ( ctx , user . UserID . String (), apikey1 . Key )
2022-10-19 21:12:03 -05:00
require . Error ( t , err )
cerr := coderdtest . SDKError ( t , err )
require . Equal ( t , http . StatusUnauthorized , cerr . StatusCode ())
resp , err := client . LoginWithPassword ( ctx , codersdk . LoginWithPasswordRequest {
Email : coderdtest . FirstUserParams . Email ,
2023-02-08 14:10:08 -06:00
Password : "MyNewSecurePassword!" ,
2022-10-19 21:12:03 -05:00
})
require . NoError ( t , err )
2022-11-09 15:31:24 +02:00
client . SetSessionToken ( resp . SessionToken )
2022-10-19 21:12:03 -05:00
// Trying to get an API key should fail since all keys are deleted
// on password change.
2023-03-02 09:39:38 -08:00
_ , err = client . APIKeyByID ( ctx , user . UserID . String (), apikey1 . Key )
2022-10-19 21:12:03 -05:00
require . Error ( t , err )
cerr = coderdtest . SDKError ( t , err )
require . Equal ( t , http . StatusNotFound , cerr . StatusCode ())
2023-03-02 09:39:38 -08:00
_ , err = client . APIKeyByID ( ctx , user . UserID . String (), apikey2 . Key )
2022-10-19 21:12:03 -05:00
require . Error ( t , err )
cerr = coderdtest . SDKError ( t , err )
require . Equal ( t , http . StatusNotFound , cerr . StatusCode ())
})
2026-06-04 14:36:25 -04:00
t . Run ( "UserAdminCannotResetOwnerPassword" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
owner := coderdtest . CreateFirstUser ( t , client )
userAdmin , _ := coderdtest . CreateAnotherUser ( t , client , owner . OrganizationID , rbac . RoleUserAdmin ())
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
err := userAdmin . UpdateUserPassword ( ctx , owner . UserID . String (), codersdk . UpdateUserPasswordRequest {
Password : "SomeNewStrongPassword!" ,
})
require . Error ( t , err , "user-admin should not be able to reset owner password" )
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
require . Equal ( t , http . StatusBadRequest , apiErr . StatusCode ())
require . Contains ( t , apiErr . Message , "Only owners can change the password of an owner" )
})
t . Run ( "OwnerCanResetOwnerPassword" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
owner := coderdtest . CreateFirstUser ( t , client )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
anotherOwner , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
Email : "another-owner@coder.com" ,
Username : "another-owner" ,
Password : "SomeStrongPassword!" ,
OrganizationIDs : [] uuid . UUID { owner . OrganizationID },
})
require . NoError ( t , err )
_ , err = client . UpdateUserRoles ( ctx , anotherOwner . ID . String (), codersdk . UpdateRoles {
Roles : [] string { rbac . RoleOwner (). String ()},
})
require . NoError ( t , err )
err = client . UpdateUserPassword ( ctx , anotherOwner . ID . String (), codersdk . UpdateUserPasswordRequest {
Password : "SomeNewStrongPassword!" ,
})
require . NoError ( t , err , "owner should be able to reset another owner's password" )
_ , err = client . LoginWithPassword ( ctx , codersdk . LoginWithPasswordRequest {
Email : "another-owner@coder.com" ,
Password : "SomeNewStrongPassword!" ,
})
require . NoError ( t , err , "other owner should login with the new password" )
})
2022-10-19 21:12:03 -05:00
t . Run ( "PasswordsMustDiffer" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
_ = coderdtest . CreateFirstUser ( t , client )
2023-03-23 17:42:20 -05:00
ctx := testutil . Context ( t , testutil . WaitLong )
2022-10-19 21:12:03 -05:00
err := client . UpdateUserPassword ( ctx , "me" , codersdk . UpdateUserPasswordRequest {
Password : coderdtest . FirstUserParams . Password ,
})
require . Error ( t , err )
cerr := coderdtest . SDKError ( t , err )
require . Equal ( t , http . StatusBadRequest , cerr . StatusCode ())
})
2022-05-06 09:20:08 -05:00
}
2022-08-09 13:16:53 -05:00
// TestInitialRoles ensures the starting roles for the first user are correct.
func TestInitialRoles ( t * testing . T ) {
t . Parallel ()
ctx := context . Background ()
client := coderdtest . New ( t , nil )
first := coderdtest . CreateFirstUser ( t , client )
2022-04-29 09:04:19 -05:00
2023-01-29 15:47:24 -06:00
roles , err := client . UserRoles ( ctx , codersdk . Me )
2022-08-09 13:16:53 -05:00
require . NoError ( t , err )
require . ElementsMatch ( t , roles . Roles , [] string {
2024-06-11 08:55:28 -05:00
codersdk . RoleOwner ,
2022-08-09 13:16:53 -05:00
}, "should be a member and admin" )
2022-04-29 09:04:19 -05:00
2024-03-05 14:06:35 -06:00
require . ElementsMatch ( t , roles . OrganizationRoles [ first . OrganizationID ], [] string {}, "should be a member" )
2022-04-29 09:04:19 -05:00
}
2022-04-26 09:00:07 -05:00
func TestPutUserSuspend ( t * testing . T ) {
t . Parallel ()
2022-08-31 11:26:36 -04:00
t . Run ( "SuspendAnOwner" , func ( t * testing . T ) {
2022-04-26 09:00:07 -05:00
t . Parallel ()
client := coderdtest . New ( t , nil )
me := coderdtest . CreateFirstUser ( t , client )
2023-02-06 17:48:21 -06:00
_ , user := coderdtest . CreateAnotherUser ( t , client , me . OrganizationID , rbac . RoleOwner ())
2022-08-31 11:26:36 -04:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
_ , err := client . UpdateUserStatus ( ctx , user . Username , codersdk . UserStatusSuspended )
require . Error ( t , err , "cannot suspend owners" )
})
t . Run ( "SuspendAnotherUser" , func ( t * testing . T ) {
t . Parallel ()
2022-09-08 21:16:16 -05:00
auditor := audit . NewMock ()
client := coderdtest . New ( t , & coderdtest . Options { Auditor : auditor })
2023-03-30 12:13:03 -05:00
numLogs := len ( auditor . AuditLogs ())
2023-02-06 15:12:50 -05:00
2022-08-31 11:26:36 -04:00
me := coderdtest . CreateFirstUser ( t , client )
2023-02-06 15:12:50 -05:00
numLogs ++ // add an audit log for user create
numLogs ++ // add an audit log for login
2023-02-06 17:48:21 -06:00
_ , user := coderdtest . CreateAnotherUser ( t , client , me . OrganizationID )
2023-02-06 15:12:50 -05:00
numLogs ++ // add an audit log for user create
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
user , err := client . UpdateUserStatus ( ctx , user . Username , codersdk . UserStatusSuspended )
2022-04-26 09:00:07 -05:00
require . NoError ( t , err )
require . Equal ( t , user . Status , codersdk . UserStatusSuspended )
2023-02-06 15:12:50 -05:00
numLogs ++ // add an audit log for user update
2023-03-30 12:13:03 -05:00
require . Len ( t , auditor . AuditLogs (), numLogs )
require . Equal ( t , database . AuditActionWrite , auditor . AuditLogs ()[ numLogs - 1 ]. Action )
2022-04-26 09:00:07 -05:00
})
t . Run ( "SuspendItSelf" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
coderdtest . CreateFirstUser ( t , client )
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
client . User ( ctx , codersdk . Me )
_ , err := client . UpdateUserStatus ( ctx , codersdk . Me , codersdk . UserStatusSuspended )
2022-04-26 09:00:07 -05:00
2022-05-16 15:29:27 -05:00
require . ErrorContains ( t , err , "suspend yourself" , "cannot suspend yourself" )
2022-04-26 09:00:07 -05:00
})
}
2023-08-02 16:31:25 +02:00
func TestActivateDormantUser ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
// Create users
me := coderdtest . CreateFirstUser ( t , client )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2024-08-23 16:23:51 -05:00
anotherUser , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
Email : "coder@coder.com" ,
Username : "coder" ,
Password : "SomeStrongPassword!" ,
OrganizationIDs : [] uuid . UUID { me . OrganizationID },
2023-08-02 16:31:25 +02:00
})
require . NoError ( t , err )
// Ensure that new user has dormant account
require . Equal ( t , codersdk . UserStatusDormant , anotherUser . Status )
// Activate user account
_ , err = client . UpdateUserStatus ( ctx , anotherUser . Username , codersdk . UserStatusActive )
require . NoError ( t , err )
// Verify if the account is active now
anotherUser , err = client . User ( ctx , anotherUser . Username )
require . NoError ( t , err )
require . Equal ( t , codersdk . UserStatusActive , anotherUser . Status )
}
2022-04-29 11:44:22 -05:00
func TestGetUser ( t * testing . T ) {
2022-03-07 11:40:54 -06:00
t . Parallel ()
2022-04-28 09:10:17 -05:00
2026-03-25 09:53:06 +00:00
// Single instance shared across all sub-tests. All lookups
// are read-only against the first user.
client := coderdtest . New ( t , nil )
firstUser := coderdtest . CreateFirstUser ( t , client )
2022-04-29 11:44:22 -05:00
t . Run ( "ByMe" , func ( t * testing . T ) {
t . Parallel ()
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
user , err := client . User ( ctx , codersdk . Me )
2022-04-29 11:44:22 -05:00
require . NoError ( t , err )
require . Equal ( t , firstUser . UserID , user . ID )
require . Equal ( t , firstUser . OrganizationID , user . OrganizationIDs [ 0 ])
})
t . Run ( "ByID" , func ( t * testing . T ) {
t . Parallel ()
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
user , err := client . User ( ctx , firstUser . UserID . String ())
2022-04-29 11:44:22 -05:00
require . NoError ( t , err )
require . Equal ( t , firstUser . UserID , user . ID )
require . Equal ( t , firstUser . OrganizationID , user . OrganizationIDs [ 0 ])
})
t . Run ( "ByUsername" , func ( t * testing . T ) {
t . Parallel ()
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
exp , err := client . User ( ctx , firstUser . UserID . String ())
2022-04-29 11:44:22 -05:00
require . NoError ( t , err )
2022-08-09 20:17:00 +03:00
user , err := client . User ( ctx , exp . Username )
2022-04-29 11:44:22 -05:00
require . NoError ( t , err )
2026-03-25 14:09:25 -05:00
require . Equal ( t , exp . ID , user . ID )
2022-04-29 11:44:22 -05:00
})
2022-03-07 11:40:54 -06:00
}
2026-03-20 12:43:03 -08:00
func TestGetUsersFilter ( t * testing . T ) {
2022-06-24 10:02:23 -05:00
t . Parallel ()
2026-03-20 12:43:03 -08:00
client , _ , api := coderdtest . NewWithAPI ( t , & coderdtest . Options {
IncludeProvisionerDaemon : true ,
OIDCConfig : & coderd . OIDCConfig {
AllowSignups : true ,
},
})
_ = coderdtest . CreateFirstUser ( t , client )
2022-08-09 20:17:00 +03:00
2026-03-20 12:43:03 -08:00
setupCtx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2022-08-09 20:17:00 +03:00
2026-04-07 14:25:32 -04:00
coderdtest . UsersFilter ( setupCtx , t , client , api . Database , nil , nil , func ( testCtx context . Context , req codersdk . UsersRequest ) [] codersdk . ReducedUser {
2026-03-20 12:43:03 -08:00
res , err := client . Users ( testCtx , req )
require . NoError ( t , err )
reduced := make ([] codersdk . ReducedUser , len ( res . Users ))
for i , user := range res . Users {
reduced [ i ] = user . ReducedUser
2022-06-24 10:02:23 -05:00
}
2026-03-20 12:43:03 -08:00
return reduced
2026-02-03 00:13:41 +11:00
})
2022-04-18 12:19:47 -05:00
}
2022-11-14 17:22:57 -05:00
func TestGetUsersPagination ( t * testing . T ) {
2022-11-08 10:58:44 -05:00
t . Parallel ()
2022-11-14 17:22:57 -05:00
client := coderdtest . New ( t , nil )
2026-03-20 12:43:03 -08:00
_ = coderdtest . CreateFirstUser ( t , client )
2022-11-08 10:58:44 -05:00
2022-11-14 17:22:57 -05:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2022-11-08 10:58:44 -05:00
2026-03-20 12:43:03 -08:00
coderdtest . UsersPagination ( ctx , t , client , nil , func ( req codersdk . UsersRequest ) ([] codersdk . ReducedUser , int ) {
res , err := client . Users ( ctx , req )
require . NoError ( t , err )
reduced := make ([] codersdk . ReducedUser , len ( res . Users ))
for i , user := range res . Users {
reduced [ i ] = user . ReducedUser
}
return reduced , res . Count
2022-11-08 10:58:44 -05:00
})
}
2022-10-06 15:02:27 -04:00
func TestPostTokens ( t * testing . T ) {
2022-03-07 11:40:54 -06:00
t . Parallel ()
2022-10-06 15:02:27 -04:00
client := coderdtest . New ( t , nil )
_ = coderdtest . CreateFirstUser ( t , client )
2022-03-07 11:40:54 -06:00
2022-10-06 15:02:27 -04:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2022-08-09 20:17:00 +03:00
2022-10-15 02:46:38 +10:00
apiKey , err := client . CreateToken ( ctx , codersdk . Me , codersdk . CreateTokenRequest {})
2022-10-06 15:02:27 -04:00
require . NotNil ( t , apiKey )
require . GreaterOrEqual ( t , len ( apiKey . Key ), 2 )
require . NoError ( t , err )
2022-03-07 11:40:54 -06:00
}
2025-04-07 14:30:10 +02:00
func TestUserTerminalFont ( t * testing . T ) {
t . Parallel ()
2026-03-25 09:53:06 +00:00
// Single instance shared across all sub-tests. Each sub-test
// creates its own non-admin user for isolation.
adminClient := coderdtest . New ( t , nil )
firstUser := coderdtest . CreateFirstUser ( t , adminClient )
2025-04-07 14:30:10 +02:00
t . Run ( "valid font" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
2025-11-28 16:50:59 +00:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
2025-04-07 14:30:10 +02:00
defer cancel ()
// given
2025-11-28 16:50:59 +00:00
initial , err := client . GetUserAppearanceSettings ( ctx , codersdk . Me )
2025-04-07 14:30:10 +02:00
require . NoError ( t , err )
require . Equal ( t , codersdk . TerminalFontName ( "" ), initial . TerminalFont )
// when
2025-11-28 16:50:59 +00:00
updated , err := client . UpdateUserAppearanceSettings ( ctx , codersdk . Me , codersdk . UpdateUserAppearanceSettingsRequest {
2025-04-07 14:30:10 +02:00
ThemePreference : "light" ,
TerminalFont : "fira-code" ,
})
require . NoError ( t , err )
// then
require . Equal ( t , codersdk . TerminalFontFiraCode , updated . TerminalFont )
})
t . Run ( "unsupported font" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
2025-11-28 16:50:59 +00:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
2025-04-07 14:30:10 +02:00
defer cancel ()
// given
2025-11-28 16:50:59 +00:00
initial , err := client . GetUserAppearanceSettings ( ctx , codersdk . Me )
2025-04-07 14:30:10 +02:00
require . NoError ( t , err )
require . Equal ( t , codersdk . TerminalFontName ( "" ), initial . TerminalFont )
// when
2025-11-28 16:50:59 +00:00
_ , err = client . UpdateUserAppearanceSettings ( ctx , codersdk . Me , codersdk . UpdateUserAppearanceSettingsRequest {
2025-04-07 14:30:10 +02:00
ThemePreference : "light" ,
TerminalFont : "foobar" ,
})
// then
require . Error ( t , err )
})
t . Run ( "undefined font is not ok" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
2025-11-28 16:50:59 +00:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
2025-04-07 14:30:10 +02:00
defer cancel ()
// given
2025-11-28 16:50:59 +00:00
initial , err := client . GetUserAppearanceSettings ( ctx , codersdk . Me )
2025-04-07 14:30:10 +02:00
require . NoError ( t , err )
require . Equal ( t , codersdk . TerminalFontName ( "" ), initial . TerminalFont )
// when
2025-11-28 16:50:59 +00:00
_ , err = client . UpdateUserAppearanceSettings ( ctx , codersdk . Me , codersdk . UpdateUserAppearanceSettingsRequest {
2025-04-07 14:30:10 +02:00
ThemePreference : "light" ,
TerminalFont : "" ,
})
// then
require . Error ( t , err )
})
}
2026-05-14 11:44:05 +07:00
func TestUserThemeMode ( t * testing . T ) {
t . Parallel ()
adminClient := coderdtest . New ( t , nil )
firstUser := coderdtest . CreateFirstUser ( t , adminClient )
t . Run ( "defaults to empty" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
initial , err := client . GetUserAppearanceSettings ( ctx , codersdk . Me )
require . NoError ( t , err )
// A fresh user has never written any theme_* key. The GET handler
// should return empty strings rather than error out.
require . Equal ( t , codersdk . ThemeModeUnset , initial . ThemeMode )
require . Equal ( t , "" , initial . ThemeLight )
require . Equal ( t , "" , initial . ThemeDark )
})
t . Run ( "sync mode roundtrip" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
updated , err := client . UpdateUserAppearanceSettings ( ctx , codersdk . Me , codersdk . UpdateUserAppearanceSettingsRequest {
ThemePreference : "dark-tritan" ,
ThemeMode : codersdk . ThemeModeSync ,
ThemeLight : "light-tritan" ,
ThemeDark : "dark-tritan" ,
TerminalFont : codersdk . TerminalFontGeistMono ,
})
require . NoError ( t , err )
require . Equal ( t , codersdk . ThemeModeSync , updated . ThemeMode )
require . Equal ( t , "light-tritan" , updated . ThemeLight )
require . Equal ( t , "dark-tritan" , updated . ThemeDark )
// Fetched values should match.
fetched , err := client . GetUserAppearanceSettings ( ctx , codersdk . Me )
require . NoError ( t , err )
require . Equal ( t , codersdk . ThemeModeSync , fetched . ThemeMode )
require . Equal ( t , "light-tritan" , fetched . ThemeLight )
require . Equal ( t , "dark-tritan" , fetched . ThemeDark )
})
t . Run ( "sync mode accepts any concrete theme per slot" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
updated , err := client . UpdateUserAppearanceSettings ( ctx , codersdk . Me , codersdk . UpdateUserAppearanceSettingsRequest {
ThemePreference : "dark-tritan" ,
ThemeMode : codersdk . ThemeModeSync ,
ThemeLight : "dark-tritan" ,
ThemeDark : "light-tritan" ,
TerminalFont : codersdk . TerminalFontGeistMono ,
})
require . NoError ( t , err )
require . Equal ( t , codersdk . ThemeModeSync , updated . ThemeMode )
require . Equal ( t , "dark-tritan" , updated . ThemeLight )
require . Equal ( t , "light-tritan" , updated . ThemeDark )
})
t . Run ( "empty theme_mode is accepted for back-compat" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
// A concrete legacy preference plus an unset mode is enough for
// modern clients to treat the user as single mode. The server does
// not write the new fields for old clients because doing so would
// erase existing sync settings.
updated , err := client . UpdateUserAppearanceSettings ( ctx , codersdk . Me , codersdk . UpdateUserAppearanceSettingsRequest {
ThemePreference : "dark" ,
TerminalFont : codersdk . TerminalFontGeistMono ,
})
require . NoError ( t , err )
require . Equal ( t , "dark" , updated . ThemePreference )
require . Equal ( t , codersdk . ThemeModeUnset , updated . ThemeMode )
require . Equal ( t , "" , updated . ThemeLight )
require . Equal ( t , "" , updated . ThemeDark )
})
t . Run ( "omitted theme fields preserve sync settings" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
_ , err := client . UpdateUserAppearanceSettings ( ctx , codersdk . Me , codersdk . UpdateUserAppearanceSettingsRequest {
ThemePreference : "dark-tritan" ,
ThemeMode : codersdk . ThemeModeSync ,
ThemeLight : "light-tritan" ,
ThemeDark : "dark-tritan" ,
TerminalFont : codersdk . TerminalFontGeistMono ,
})
require . NoError ( t , err )
updated , err := client . UpdateUserAppearanceSettings ( ctx , codersdk . Me , codersdk . UpdateUserAppearanceSettingsRequest {
ThemePreference : "dark" ,
TerminalFont : codersdk . TerminalFontFiraCode ,
})
require . NoError ( t , err )
require . Equal ( t , "dark" , updated . ThemePreference )
require . Equal ( t , codersdk . ThemeModeSync , updated . ThemeMode )
require . Equal ( t , "light-tritan" , updated . ThemeLight )
require . Equal ( t , "dark-tritan" , updated . ThemeDark )
require . Equal ( t , codersdk . TerminalFontFiraCode , updated . TerminalFont )
fetched , err := client . GetUserAppearanceSettings ( ctx , codersdk . Me )
require . NoError ( t , err )
require . Equal ( t , "dark" , fetched . ThemePreference )
require . Equal ( t , codersdk . ThemeModeSync , fetched . ThemeMode )
require . Equal ( t , "light-tritan" , fetched . ThemeLight )
require . Equal ( t , "dark-tritan" , fetched . ThemeDark )
require . Equal ( t , codersdk . TerminalFontFiraCode , fetched . TerminalFont )
})
t . Run ( "single mode with omitted slots preserves sync settings" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
_ , err := client . UpdateUserAppearanceSettings ( ctx , codersdk . Me , codersdk . UpdateUserAppearanceSettingsRequest {
ThemePreference : "dark-tritan" ,
ThemeMode : codersdk . ThemeModeSync ,
ThemeLight : "light-tritan" ,
ThemeDark : "dark-tritan" ,
TerminalFont : codersdk . TerminalFontGeistMono ,
})
require . NoError ( t , err )
updated , err := client . UpdateUserAppearanceSettings ( ctx , codersdk . Me , codersdk . UpdateUserAppearanceSettingsRequest {
ThemePreference : "dark" ,
ThemeMode : codersdk . ThemeModeSingle ,
TerminalFont : codersdk . TerminalFontFiraCode ,
})
require . NoError ( t , err )
require . Equal ( t , "dark" , updated . ThemePreference )
require . Equal ( t , codersdk . ThemeModeSingle , updated . ThemeMode )
require . Equal ( t , "light-tritan" , updated . ThemeLight )
require . Equal ( t , "dark-tritan" , updated . ThemeDark )
require . Equal ( t , codersdk . TerminalFontFiraCode , updated . TerminalFont )
fetched , err := client . GetUserAppearanceSettings ( ctx , codersdk . Me )
require . NoError ( t , err )
require . Equal ( t , "dark" , fetched . ThemePreference )
require . Equal ( t , codersdk . ThemeModeSingle , fetched . ThemeMode )
require . Equal ( t , "light-tritan" , fetched . ThemeLight )
require . Equal ( t , "dark-tritan" , fetched . ThemeDark )
require . Equal ( t , codersdk . TerminalFontFiraCode , fetched . TerminalFont )
})
t . Run ( "single mode with explicit slots updates slots" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
updated , err := client . UpdateUserAppearanceSettings ( ctx , codersdk . Me , codersdk . UpdateUserAppearanceSettingsRequest {
ThemePreference : "light-tritan" ,
ThemeMode : codersdk . ThemeModeSingle ,
ThemeLight : "dark-tritan" ,
ThemeDark : "light-protan-deuter" ,
TerminalFont : codersdk . TerminalFontFiraCode ,
})
require . NoError ( t , err )
require . Equal ( t , "light-tritan" , updated . ThemePreference )
require . Equal ( t , codersdk . ThemeModeSingle , updated . ThemeMode )
require . Equal ( t , "dark-tritan" , updated . ThemeLight )
require . Equal ( t , "light-protan-deuter" , updated . ThemeDark )
require . Equal ( t , codersdk . TerminalFontFiraCode , updated . TerminalFont )
fetched , err := client . GetUserAppearanceSettings ( ctx , codersdk . Me )
require . NoError ( t , err )
require . Equal ( t , "light-tritan" , fetched . ThemePreference )
require . Equal ( t , codersdk . ThemeModeSingle , fetched . ThemeMode )
require . Equal ( t , "dark-tritan" , fetched . ThemeLight )
require . Equal ( t , "light-protan-deuter" , fetched . ThemeDark )
require . Equal ( t , codersdk . TerminalFontFiraCode , fetched . TerminalFont )
})
t . Run ( "single mode with one explicit slot updates only that slot" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
_ , err := client . UpdateUserAppearanceSettings ( ctx , codersdk . Me , codersdk . UpdateUserAppearanceSettingsRequest {
ThemePreference : "dark-tritan" ,
ThemeMode : codersdk . ThemeModeSync ,
ThemeLight : "light-tritan" ,
ThemeDark : "dark-tritan" ,
TerminalFont : codersdk . TerminalFontGeistMono ,
})
require . NoError ( t , err )
updated , err := client . UpdateUserAppearanceSettings ( ctx , codersdk . Me , codersdk . UpdateUserAppearanceSettingsRequest {
ThemePreference : "light" ,
ThemeMode : codersdk . ThemeModeSingle ,
ThemeLight : "light-protan-deuter" ,
TerminalFont : codersdk . TerminalFontFiraCode ,
})
require . NoError ( t , err )
require . Equal ( t , "light" , updated . ThemePreference )
require . Equal ( t , codersdk . ThemeModeSingle , updated . ThemeMode )
require . Equal ( t , "light-protan-deuter" , updated . ThemeLight )
require . Equal ( t , "dark-tritan" , updated . ThemeDark )
require . Equal ( t , codersdk . TerminalFontFiraCode , updated . TerminalFont )
fetched , err := client . GetUserAppearanceSettings ( ctx , codersdk . Me )
require . NoError ( t , err )
require . Equal ( t , "light" , fetched . ThemePreference )
require . Equal ( t , codersdk . ThemeModeSingle , fetched . ThemeMode )
require . Equal ( t , "light-protan-deuter" , fetched . ThemeLight )
require . Equal ( t , "dark-tritan" , fetched . ThemeDark )
require . Equal ( t , codersdk . TerminalFontFiraCode , fetched . TerminalFont )
})
t . Run ( "legacy auto with omitted theme_mode clears mode" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
_ , err := client . UpdateUserAppearanceSettings ( ctx , codersdk . Me , codersdk . UpdateUserAppearanceSettingsRequest {
ThemePreference : "dark-tritan" ,
ThemeMode : codersdk . ThemeModeSync ,
ThemeLight : "light-tritan" ,
ThemeDark : "dark-tritan" ,
TerminalFont : codersdk . TerminalFontGeistMono ,
})
require . NoError ( t , err )
updated , err := client . UpdateUserAppearanceSettings ( ctx , codersdk . Me , codersdk . UpdateUserAppearanceSettingsRequest {
ThemePreference : "auto" ,
TerminalFont : codersdk . TerminalFontFiraCode ,
})
require . NoError ( t , err )
require . Equal ( t , "auto" , updated . ThemePreference )
require . Equal ( t , codersdk . ThemeModeUnset , updated . ThemeMode )
require . Equal ( t , "light-tritan" , updated . ThemeLight )
require . Equal ( t , "dark-tritan" , updated . ThemeDark )
require . Equal ( t , codersdk . TerminalFontFiraCode , updated . TerminalFont )
fetched , err := client . GetUserAppearanceSettings ( ctx , codersdk . Me )
require . NoError ( t , err )
require . Equal ( t , "auto" , fetched . ThemePreference )
require . Equal ( t , codersdk . ThemeModeUnset , fetched . ThemeMode )
require . Equal ( t , "light-tritan" , fetched . ThemeLight )
require . Equal ( t , "dark-tritan" , fetched . ThemeDark )
require . Equal ( t , codersdk . TerminalFontFiraCode , fetched . TerminalFont )
})
t . Run ( "invalid theme_mode is rejected" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
_ , err := client . UpdateUserAppearanceSettings ( ctx , codersdk . Me , codersdk . UpdateUserAppearanceSettingsRequest {
ThemePreference : "dark" ,
ThemeMode : codersdk . ThemeMode ( "wizard" ),
TerminalFont : codersdk . TerminalFontGeistMono ,
})
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
require . Equal ( t , http . StatusBadRequest , apiErr . StatusCode ())
})
t . Run ( "invalid theme slots are rejected" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
for _ , tc := range [] struct {
name string
themeMode codersdk . ThemeMode
themeLight string
themeDark string
}{
{
name : "arbitrary light slot" ,
themeMode : codersdk . ThemeModeSync ,
themeLight : "../../etc/passwd" ,
themeDark : "dark" ,
},
{
name : "arbitrary dark slot" ,
themeMode : codersdk . ThemeModeSync ,
themeLight : "light" ,
themeDark : "xss-payload" ,
},
{
name : "empty light slot in sync mode" ,
themeMode : codersdk . ThemeModeSync ,
themeLight : "" ,
themeDark : "dark" ,
},
{
name : "empty dark slot in sync mode" ,
themeMode : codersdk . ThemeModeSync ,
themeLight : "light" ,
themeDark : "" ,
},
{
name : "arbitrary light slot in single mode" ,
themeMode : codersdk . ThemeModeSingle ,
themeLight : "../../etc/passwd" ,
},
{
name : "arbitrary dark slot with omitted mode" ,
themeDark : "xss-payload" ,
},
} {
t . Run ( tc . name , func ( t * testing . T ) {
_ , err := client . UpdateUserAppearanceSettings ( ctx , codersdk . Me , codersdk . UpdateUserAppearanceSettingsRequest {
ThemePreference : "dark" ,
ThemeMode : tc . themeMode ,
ThemeLight : tc . themeLight ,
ThemeDark : tc . themeDark ,
TerminalFont : codersdk . TerminalFontGeistMono ,
})
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
require . Equal ( t , http . StatusBadRequest , apiErr . StatusCode ())
})
}
})
}
2026-04-24 12:29:08 +01:00
func TestThinkingDisplayMode ( t * testing . T ) {
t . Parallel ()
adminClient := coderdtest . New ( t , nil )
firstUser := coderdtest . CreateFirstUser ( t , adminClient )
t . Run ( "defaults to auto" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
settings , err := client . GetUserPreferenceSettings ( ctx , codersdk . Me )
require . NoError ( t , err )
require . Equal ( t , codersdk . ThinkingDisplayModeAuto , settings . ThinkingDisplayMode )
})
t . Run ( "round-trips a valid mode" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
updated , err := client . UpdateUserPreferenceSettings ( ctx , codersdk . Me , codersdk . UpdateUserPreferenceSettingsRequest {
ThinkingDisplayMode : codersdk . ThinkingDisplayModeAlwaysCollapsed ,
})
require . NoError ( t , err )
require . Equal ( t , codersdk . ThinkingDisplayModeAlwaysCollapsed , updated . ThinkingDisplayMode )
settings , err := client . GetUserPreferenceSettings ( ctx , codersdk . Me )
require . NoError ( t , err )
require . Equal ( t , codersdk . ThinkingDisplayModeAlwaysCollapsed , settings . ThinkingDisplayMode )
})
t . Run ( "rejects invalid mode" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
_ , err := client . UpdateUserPreferenceSettings ( ctx , codersdk . Me , codersdk . UpdateUserPreferenceSettingsRequest {
ThinkingDisplayMode : "bogus" ,
})
var sdkErr * codersdk . Error
require . ErrorAs ( t , err , & sdkErr )
require . Equal ( t , http . StatusBadRequest , sdkErr . StatusCode ())
})
t . Run ( "empty mode preserves stored value" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
// Set a non-default mode.
_ , err := client . UpdateUserPreferenceSettings ( ctx , codersdk . Me , codersdk . UpdateUserPreferenceSettingsRequest {
ThinkingDisplayMode : codersdk . ThinkingDisplayModePreview ,
})
require . NoError ( t , err )
// Send an update that omits thinking_display_mode (zero value).
2026-09-11 03:48:56 +02:00
updated , err := client . UpdateUserPreferenceSettings ( ctx , codersdk . Me , codersdk . UpdateUserPreferenceSettingsRequest {})
2026-04-24 12:29:08 +01:00
require . NoError ( t , err )
require . Equal ( t , codersdk . ThinkingDisplayModePreview , updated . ThinkingDisplayMode )
})
}
2026-05-12 10:09:34 +02:00
func TestAgentChatSendShortcutPreference ( t * testing . T ) {
t . Parallel ()
adminClient := coderdtest . New ( t , nil )
firstUser := coderdtest . CreateFirstUser ( t , adminClient )
requireValidationField := func ( t * testing . T , err error , field string ) {
t . Helper ()
var sdkErr * codersdk . Error
require . ErrorAs ( t , err , & sdkErr )
require . Equal ( t , http . StatusBadRequest , sdkErr . StatusCode ())
require . Len ( t , sdkErr . Validations , 1 )
require . Equal ( t , field , sdkErr . Validations [ 0 ]. Field )
}
t . Run ( "defaults to enter" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
settings , err := client . GetUserPreferenceSettings ( ctx , codersdk . Me )
require . NoError ( t , err )
require . Equal ( t , codersdk . AgentChatSendShortcutEnter , settings . AgentChatSendShortcut )
})
t . Run ( "round-trips shortcut" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
updated , err := client . UpdateUserPreferenceSettings ( ctx , codersdk . Me , codersdk . UpdateUserPreferenceSettingsRequest {
AgentChatSendShortcut : codersdk . AgentChatSendShortcutModifierEnter ,
})
require . NoError ( t , err )
require . Equal ( t , codersdk . AgentChatSendShortcutModifierEnter , updated . AgentChatSendShortcut )
settings , err := client . GetUserPreferenceSettings ( ctx , codersdk . Me )
require . NoError ( t , err )
require . Equal ( t , codersdk . AgentChatSendShortcutModifierEnter , settings . AgentChatSendShortcut )
})
t . Run ( "rejects invalid shortcut" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
_ , err := client . UpdateUserPreferenceSettings ( ctx , codersdk . Me , codersdk . UpdateUserPreferenceSettingsRequest {
AgentChatSendShortcut : codersdk . AgentChatSendShortcut ( "bogus" ),
})
requireValidationField ( t , err , "agent_chat_send_shortcut" )
})
t . Run ( "updates preserve stored shortcut" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
_ , err := client . UpdateUserPreferenceSettings ( ctx , codersdk . Me , codersdk . UpdateUserPreferenceSettingsRequest {
AgentChatSendShortcut : codersdk . AgentChatSendShortcutModifierEnter ,
ThinkingDisplayMode : codersdk . ThinkingDisplayModePreview ,
})
require . NoError ( t , err )
updated , err := client . UpdateUserPreferenceSettings ( ctx , codersdk . Me , codersdk . UpdateUserPreferenceSettingsRequest {
ThinkingDisplayMode : codersdk . ThinkingDisplayModeAlwaysExpanded ,
})
require . NoError ( t , err )
require . Equal ( t , codersdk . ThinkingDisplayModeAlwaysExpanded , updated . ThinkingDisplayMode )
require . Equal ( t , codersdk . AgentChatSendShortcutModifierEnter , updated . AgentChatSendShortcut )
})
}
2026-05-07 20:15:28 +01:00
func TestAgentDisplayModePreferences ( t * testing . T ) {
t . Parallel ()
adminClient := coderdtest . New ( t , nil )
firstUser := coderdtest . CreateFirstUser ( t , adminClient )
requireValidationField := func ( t * testing . T , err error , field string ) {
t . Helper ()
var sdkErr * codersdk . Error
require . ErrorAs ( t , err , & sdkErr )
require . Equal ( t , http . StatusBadRequest , sdkErr . StatusCode ())
require . Len ( t , sdkErr . Validations , 1 )
require . Equal ( t , field , sdkErr . Validations [ 0 ]. Field )
}
2026-05-28 16:54:52 +01:00
t . Run ( "defaults shell tools to always collapsed" , func ( t * testing . T ) {
2026-05-07 20:15:28 +01:00
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
settings , err := client . GetUserPreferenceSettings ( ctx , codersdk . Me )
require . NoError ( t , err )
2026-05-28 16:54:52 +01:00
require . Equal ( t , codersdk . AgentDisplayModeAlwaysCollapsed , settings . ShellToolDisplayMode )
require . Empty ( t , settings . CodeDiffDisplayMode )
2026-05-07 20:15:28 +01:00
})
2026-05-14 14:25:07 +01:00
t . Run ( "round-trips shell tool display mode" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
for _ , mode := range [] codersdk . AgentDisplayMode {
codersdk . AgentDisplayModeAlwaysExpanded ,
codersdk . AgentDisplayModeAlwaysCollapsed ,
} {
updated , err := client . UpdateUserPreferenceSettings ( ctx , codersdk . Me , codersdk . UpdateUserPreferenceSettingsRequest {
ShellToolDisplayMode : mode ,
})
require . NoError ( t , err )
require . Equal ( t , mode , updated . ShellToolDisplayMode )
settings , err := client . GetUserPreferenceSettings ( ctx , codersdk . Me )
require . NoError ( t , err )
require . Equal ( t , mode , settings . ShellToolDisplayMode )
}
})
2026-05-07 20:15:28 +01:00
t . Run ( "round-trips code diff display mode" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
for _ , mode := range [] codersdk . AgentDisplayMode {
codersdk . AgentDisplayModeAlwaysExpanded ,
codersdk . AgentDisplayModeAlwaysCollapsed ,
} {
updated , err := client . UpdateUserPreferenceSettings ( ctx , codersdk . Me , codersdk . UpdateUserPreferenceSettingsRequest {
CodeDiffDisplayMode : mode ,
})
require . NoError ( t , err )
require . Equal ( t , mode , updated . CodeDiffDisplayMode )
settings , err := client . GetUserPreferenceSettings ( ctx , codersdk . Me )
require . NoError ( t , err )
require . Equal ( t , mode , settings . CodeDiffDisplayMode )
}
})
t . Run ( "updates preserve stored display modes" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
_ , err := client . UpdateUserPreferenceSettings ( ctx , codersdk . Me , codersdk . UpdateUserPreferenceSettingsRequest {
2026-05-14 14:25:07 +01:00
ThinkingDisplayMode : codersdk . ThinkingDisplayModePreview ,
ShellToolDisplayMode : codersdk . AgentDisplayModeAlwaysCollapsed ,
CodeDiffDisplayMode : codersdk . AgentDisplayModeAlwaysExpanded ,
2026-05-07 20:15:28 +01:00
})
require . NoError ( t , err )
updated , err := client . UpdateUserPreferenceSettings ( ctx , codersdk . Me , codersdk . UpdateUserPreferenceSettingsRequest {
2026-05-14 14:25:07 +01:00
ShellToolDisplayMode : codersdk . AgentDisplayModeAlwaysExpanded ,
2026-05-07 20:15:28 +01:00
})
require . NoError ( t , err )
2026-05-14 14:25:07 +01:00
require . Equal ( t , codersdk . ThinkingDisplayModePreview , updated . ThinkingDisplayMode )
require . Equal ( t , codersdk . AgentDisplayModeAlwaysExpanded , updated . ShellToolDisplayMode )
2026-05-07 20:15:28 +01:00
require . Equal ( t , codersdk . AgentDisplayModeAlwaysExpanded , updated . CodeDiffDisplayMode )
settings , err := client . GetUserPreferenceSettings ( ctx , codersdk . Me )
require . NoError ( t , err )
2026-05-14 14:25:07 +01:00
require . Equal ( t , codersdk . ThinkingDisplayModePreview , settings . ThinkingDisplayMode )
require . Equal ( t , codersdk . AgentDisplayModeAlwaysExpanded , settings . ShellToolDisplayMode )
2026-05-07 20:15:28 +01:00
require . Equal ( t , codersdk . AgentDisplayModeAlwaysExpanded , settings . CodeDiffDisplayMode )
})
2026-05-14 14:25:07 +01:00
t . Run ( "rejects invalid shell tool display mode" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
for _ , tt := range [] struct {
name string
mode codersdk . AgentDisplayMode
}{
{
name : "bogus" ,
mode : codersdk . AgentDisplayMode ( "bogus" ),
},
{
name : "thinking preview" ,
mode : codersdk . AgentDisplayMode ( codersdk . ThinkingDisplayModePreview ),
},
} {
t . Run ( tt . name , func ( t * testing . T ) {
_ , err := client . UpdateUserPreferenceSettings ( ctx , codersdk . Me , codersdk . UpdateUserPreferenceSettingsRequest {
ShellToolDisplayMode : tt . mode ,
})
requireValidationField ( t , err , "shell_tool_display_mode" )
})
}
})
2026-05-07 20:15:28 +01:00
t . Run ( "rejects invalid code diff display mode" , func ( t * testing . T ) {
t . Parallel ()
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
for _ , tt := range [] struct {
name string
mode codersdk . AgentDisplayMode
}{
{
name : "bogus" ,
mode : codersdk . AgentDisplayMode ( "bogus" ),
},
{
name : "thinking preview" ,
mode : codersdk . AgentDisplayMode ( codersdk . ThinkingDisplayModePreview ),
},
} {
t . Run ( tt . name , func ( t * testing . T ) {
_ , err := client . UpdateUserPreferenceSettings ( ctx , codersdk . Me , codersdk . UpdateUserPreferenceSettingsRequest {
CodeDiffDisplayMode : tt . mode ,
})
requireValidationField ( t , err , "code_diff_display_mode" )
})
}
})
}
2022-05-09 21:38:20 -05:00
func TestWorkspacesByUser ( t * testing . T ) {
t . Parallel ()
t . Run ( "Empty" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
_ = coderdtest . CreateFirstUser ( t , client )
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2022-11-10 13:25:46 -05:00
res , err := client . Workspaces ( ctx , codersdk . WorkspaceFilter {
2022-05-18 10:09:07 -05:00
Owner : codersdk . Me ,
})
2022-05-09 21:38:20 -05:00
require . NoError ( t , err )
2022-11-10 13:25:46 -05:00
require . Len ( t , res . Workspaces , 0 )
2022-05-09 21:38:20 -05:00
})
t . Run ( "Access" , func ( t * testing . T ) {
t . Parallel ()
2022-09-04 11:28:09 -05:00
client := coderdtest . New ( t , & coderdtest . Options { IncludeProvisionerDaemon : true })
2022-05-09 21:38:20 -05:00
user := coderdtest . CreateFirstUser ( t , client )
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
2024-08-23 16:23:51 -05:00
newUser , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
Email : "test@coder.com" ,
Username : "someone" ,
Password : "MySecurePassword!" ,
OrganizationIDs : [] uuid . UUID { user . OrganizationID },
2022-05-09 21:38:20 -05:00
})
require . NoError ( t , err )
2022-08-09 20:17:00 +03:00
auth , err := client . LoginWithPassword ( ctx , codersdk . LoginWithPasswordRequest {
2022-05-09 21:38:20 -05:00
Email : newUser . Email ,
2023-02-08 14:10:08 -06:00
Password : "MySecurePassword!" ,
2022-05-09 21:38:20 -05:00
})
require . NoError ( t , err )
newUserClient := codersdk . New ( client . URL )
2022-11-09 15:31:24 +02:00
newUserClient . SetSessionToken ( auth . SessionToken )
2022-05-09 21:38:20 -05:00
version := coderdtest . CreateTemplateVersion ( t , client , user . OrganizationID , nil )
2023-10-03 11:02:56 -06:00
coderdtest . AwaitTemplateVersionJobCompleted ( t , client , version . ID )
2022-05-09 21:38:20 -05:00
template := coderdtest . CreateTemplate ( t , client , user . OrganizationID , version . ID )
2024-07-30 10:44:02 -06:00
coderdtest . CreateWorkspace ( t , client , template . ID )
2022-05-09 21:38:20 -05:00
2022-11-10 13:25:46 -05:00
res , err := newUserClient . Workspaces ( ctx , codersdk . WorkspaceFilter { Owner : codersdk . Me })
2022-05-09 21:38:20 -05:00
require . NoError ( t , err )
2022-11-10 13:25:46 -05:00
require . Len ( t , res . Workspaces , 0 )
2022-05-09 21:38:20 -05:00
2022-11-10 13:25:46 -05:00
res , err = client . Workspaces ( ctx , codersdk . WorkspaceFilter { Owner : codersdk . Me })
2022-05-09 21:38:20 -05:00
require . NoError ( t , err )
2022-11-10 13:25:46 -05:00
require . Len ( t , res . Workspaces , 1 )
2022-05-09 21:38:20 -05:00
})
}
2023-08-02 16:31:25 +02:00
func TestDormantUser ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , & coderdtest . Options { IncludeProvisionerDaemon : true })
user := coderdtest . CreateFirstUser ( t , client )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
// Create a new user
2024-08-23 16:23:51 -05:00
newUser , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
Email : "test@coder.com" ,
Username : "someone" ,
Password : "MySecurePassword!" ,
OrganizationIDs : [] uuid . UUID { user . OrganizationID },
2023-08-02 16:31:25 +02:00
})
require . NoError ( t , err )
// User should be dormant as they haven't logged in yet
users , err := client . Users ( ctx , codersdk . UsersRequest { Search : newUser . Username })
require . NoError ( t , err )
require . Len ( t , users . Users , 1 )
require . Equal ( t , codersdk . UserStatusDormant , users . Users [ 0 ]. Status )
// User logs in now
_ , err = client . LoginWithPassword ( ctx , codersdk . LoginWithPasswordRequest {
Email : newUser . Email ,
Password : "MySecurePassword!" ,
})
require . NoError ( t , err )
// User status should be active now
users , err = client . Users ( ctx , codersdk . UsersRequest { Search : newUser . Username })
require . NoError ( t , err )
require . Len ( t , users . Users , 1 )
require . Equal ( t , codersdk . UserStatusActive , users . Users [ 0 ]. Status )
}
2022-06-02 09:01:45 -05:00
// TestSuspendedPagination is when the after_id is a suspended record.
// The database query should still return the correct page, as the after_id
// is in a subquery that finds the record regardless of its status.
// This is mainly to confirm the db fake has the same behavior.
func TestSuspendedPagination ( t * testing . T ) {
t . Parallel ()
2022-09-14 20:21:53 -05:00
t . Skip ( "This fails when two users are created at the exact same time. The reason is unknown... See: https://github.com/coder/coder/actions/runs/3057047622/jobs/4931863163" )
2023-01-05 12:05:20 -06:00
client := coderdtest . New ( t , nil )
2022-06-02 09:01:45 -05:00
coderdtest . CreateFirstUser ( t , client )
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
2022-08-21 17:32:53 -05:00
t . Cleanup ( cancel )
2022-08-09 20:17:00 +03:00
me , err := client . User ( ctx , codersdk . Me )
2022-06-02 09:01:45 -05:00
require . NoError ( t , err )
orgID := me . OrganizationIDs [ 0 ]
total := 10
users := make ([] codersdk . User , 0 , total )
// Create users
for i := 0 ; i < total ; i ++ {
email := fmt . Sprintf ( "%d@coder.com" , i )
username := fmt . Sprintf ( "user%d" , i )
2024-08-23 16:23:51 -05:00
user , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
Email : email ,
Username : username ,
Password : "MySecurePassword!" ,
OrganizationIDs : [] uuid . UUID { orgID },
2022-06-02 09:01:45 -05:00
})
require . NoError ( t , err )
users = append ( users , user )
}
sortUsers ( users )
deletedUser := users [ 2 ]
expected := users [ 3 : 8 ]
_ , err = client . UpdateUserStatus ( ctx , deletedUser . ID . String (), codersdk . UserStatusSuspended )
require . NoError ( t , err , "suspend user" )
page , err := client . Users ( ctx , codersdk . UsersRequest {
Pagination : codersdk . Pagination {
Limit : len ( expected ),
AfterID : deletedUser . ID ,
},
})
require . NoError ( t , err )
2022-11-14 17:22:57 -05:00
require . Equal ( t , expected , page . Users , "expected page" )
2022-06-02 09:01:45 -05:00
}
2024-01-30 16:02:21 -06:00
func TestUserAutofillParameters ( t * testing . T ) {
t . Parallel ()
t . Run ( "NotSelf" , func ( t * testing . T ) {
t . Parallel ()
client1 , _ , api := coderdtest . NewWithAPI ( t , & coderdtest . Options {})
u1 := coderdtest . CreateFirstUser ( t , client1 )
client2 , u2 := coderdtest . CreateAnotherUser ( t , client1 , u1 . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
db := api . Database
version := dbfake . TemplateVersion ( t , db ). Seed ( database . TemplateVersion {
CreatedBy : u1 . UserID ,
OrganizationID : u1 . OrganizationID ,
}). Params ( database . TemplateVersionParameter {
Name : "param" ,
Required : true ,
}). Do ()
_ , err := client2 . UserAutofillParameters (
ctx ,
u1 . UserID . String (),
version . Template . ID ,
)
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
2026-02-13 08:19:07 -06:00
require . Equal ( t , http . StatusNotFound , apiErr . StatusCode ())
2024-01-30 16:02:21 -06:00
// u1 should be able to read u2's parameters as u1 is site admin.
_ , err = client1 . UserAutofillParameters (
ctx ,
u2 . ID . String (),
version . Template . ID ,
)
require . NoError ( t , err )
})
t . Run ( "FindsParameters" , func ( t * testing . T ) {
t . Parallel ()
client1 , _ , api := coderdtest . NewWithAPI ( t , & coderdtest . Options {})
u1 := coderdtest . CreateFirstUser ( t , client1 )
client2 , u2 := coderdtest . CreateAnotherUser ( t , client1 , u1 . OrganizationID )
db := api . Database
version := dbfake . TemplateVersion ( t , db ). Seed ( database . TemplateVersion {
CreatedBy : u1 . UserID ,
OrganizationID : u1 . OrganizationID ,
}). Params ( database . TemplateVersionParameter {
Name : "param" ,
Required : true ,
},
database . TemplateVersionParameter {
Name : "param2" ,
Ephemeral : true ,
},
). Do ()
2024-10-22 09:20:54 -05:00
dbfake . WorkspaceBuild ( t , db , database . WorkspaceTable {
2024-01-30 16:02:21 -06:00
OwnerID : u2 . ID ,
TemplateID : version . Template . ID ,
OrganizationID : u1 . OrganizationID ,
}). Params (
database . WorkspaceBuildParameter {
Name : "param" ,
Value : "foo" ,
},
database . WorkspaceBuildParameter {
Name : "param2" ,
Value : "bar" ,
},
). Do ()
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
// Use client2 since client1 is site admin, so
// we don't get good coverage on RBAC working.
params , err := client2 . UserAutofillParameters (
ctx ,
u2 . ID . String (),
version . Template . ID ,
)
require . NoError ( t , err )
require . Equal ( t , 1 , len ( params ))
require . Equal ( t , "param" , params [ 0 ]. Name )
require . Equal ( t , "foo" , params [ 0 ]. Value )
// Verify that latest parameter value is returned.
2024-10-22 09:20:54 -05:00
dbfake . WorkspaceBuild ( t , db , database . WorkspaceTable {
2024-01-30 16:02:21 -06:00
OrganizationID : u1 . OrganizationID ,
OwnerID : u2 . ID ,
TemplateID : version . Template . ID ,
}). Params (
database . WorkspaceBuildParameter {
Name : "param" ,
Value : "foo_new" ,
},
). Do ()
params , err = client2 . UserAutofillParameters (
ctx ,
u2 . ID . String (),
version . Template . ID ,
)
require . NoError ( t , err )
require . Equal ( t , 1 , len ( params ))
require . Equal ( t , "param" , params [ 0 ]. Name )
require . Equal ( t , "foo_new" , params [ 0 ]. Value )
})
}
2022-04-22 15:27:55 -05:00
// TestPaginatedUsers creates a list of users, then tries to paginate through
// them using different page sizes.
func TestPaginatedUsers ( t * testing . T ) {
t . Parallel ()
2023-12-04 11:05:17 -05:00
client , db := coderdtest . NewWithDatabase ( t , nil )
2022-04-22 15:27:55 -05:00
coderdtest . CreateFirstUser ( t , client )
2022-08-09 20:17:00 +03:00
// This test takes longer than a long time.
2023-03-21 09:10:22 -05:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong * 4 )
2022-08-21 17:32:53 -05:00
t . Cleanup ( cancel )
2022-08-09 20:17:00 +03:00
me , err := client . User ( ctx , codersdk . Me )
2022-04-22 15:27:55 -05:00
require . NoError ( t , err )
2023-03-21 09:10:22 -05:00
// When 50 users exist
total := 50
2023-12-04 11:05:17 -05:00
allUsers := make ([] database . User , total + 1 )
allUsers [ 0 ] = database . User {
Email : me . Email ,
Username : me . Username ,
}
specialUsers := make ([] database . User , total / 2 )
2022-08-09 20:17:00 +03:00
2023-12-04 11:05:17 -05:00
eg , _ := errgroup . WithContext ( ctx )
2022-04-22 15:27:55 -05:00
// Create users
for i := 0 ; i < total ; i ++ {
2022-08-09 20:17:00 +03:00
eg . Go ( func () error {
email := fmt . Sprintf ( "%d@coder.com" , i )
username := fmt . Sprintf ( "user%d" , i )
if i % 2 == 0 {
email = fmt . Sprintf ( "%d@gmail.com" , i )
username = fmt . Sprintf ( "specialuser%d" , i )
}
2023-06-06 12:37:41 +02:00
if i % 3 == 0 {
username = strings . ToUpper ( username )
}
2023-12-04 11:05:17 -05:00
// We used to use the API to ceate users, but that is slow.
// Instead, we create them directly in the database now
// to prevent timeout flakes.
newUser := dbgen . User ( t , db , database . User {
Email : email ,
Username : username ,
2022-08-09 20:17:00 +03:00
})
allUsers [ i + 1 ] = newUser
if i % 2 == 0 {
specialUsers [ i / 2 ] = newUser
}
return nil
2022-04-22 15:27:55 -05:00
})
}
2022-08-09 20:17:00 +03:00
err = eg . Wait ()
require . NoError ( t , err , "create users failed" )
2022-04-22 15:27:55 -05:00
2023-06-06 08:47:59 +02:00
// Sorting the users will sort by username.
2023-12-04 11:05:17 -05:00
sortDatabaseUsers ( allUsers )
sortDatabaseUsers ( specialUsers )
2022-04-25 10:27:08 -05:00
2022-04-22 15:27:55 -05:00
gmailSearch := func ( request codersdk . UsersRequest ) codersdk . UsersRequest {
request . Search = "gmail"
return request
}
usernameSearch := func ( request codersdk . UsersRequest ) codersdk . UsersRequest {
request . Search = "specialuser"
return request
}
2022-08-09 20:17:00 +03:00
tests := [] struct {
name string
limit int
2023-12-04 11:05:17 -05:00
allUsers [] database . User
2022-08-09 20:17:00 +03:00
opt func ( request codersdk . UsersRequest ) codersdk . UsersRequest
}{
{ name : "all users" , limit : 10 , allUsers : allUsers },
{ name : "all users" , limit : 5 , allUsers : allUsers },
{ name : "all users" , limit : 3 , allUsers : allUsers },
{ name : "gmail search" , limit : 3 , allUsers : specialUsers , opt : gmailSearch },
{ name : "gmail search" , limit : 7 , allUsers : specialUsers , opt : gmailSearch },
{ name : "username search" , limit : 3 , allUsers : specialUsers , opt : usernameSearch },
{ name : "username search" , limit : 3 , allUsers : specialUsers , opt : usernameSearch },
}
for _ , tt := range tests {
t . Run ( fmt . Sprintf ( "%s %d" , tt . name , tt . limit ), func ( t * testing . T ) {
t . Parallel ()
// This test takes longer than a long time.
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong * 2 )
defer cancel ()
assertPagination ( ctx , t , client , tt . limit , tt . allUsers , tt . opt )
})
}
2022-04-22 15:27:55 -05:00
}
// Assert pagination will page through the list of all users using the given
// limit for each page. The 'allUsers' is the expected full list to compare
// against.
2023-12-04 11:05:17 -05:00
func assertPagination ( ctx context . Context , t * testing . T , client * codersdk . Client , limit int , allUsers [] database . User ,
2022-08-09 20:17:00 +03:00
opt func ( request codersdk . UsersRequest ) codersdk . UsersRequest ,
) {
2022-04-22 15:27:55 -05:00
var count int
if opt == nil {
opt = func ( request codersdk . UsersRequest ) codersdk . UsersRequest {
return request
}
}
// Check the first page
page , err := client . Users ( ctx , opt ( codersdk . UsersRequest {
2022-05-10 10:44:09 +03:00
Pagination : codersdk . Pagination {
Limit : limit ,
},
2022-04-22 15:27:55 -05:00
}))
require . NoError ( t , err , "first page" )
2023-12-04 11:05:17 -05:00
require . Equalf ( t , onlyUsernames ( page . Users ), onlyUsernames ( allUsers [: limit ]), "first page, limit=%d" , limit )
2022-11-14 17:22:57 -05:00
count += len ( page . Users )
2022-04-22 15:27:55 -05:00
2026-08-21 23:46:27 -06:00
for len ( page . Users ) != 0 {
2022-11-14 17:22:57 -05:00
afterCursor := page . Users [ len ( page . Users ) - 1 ]. ID
2022-04-22 15:27:55 -05:00
// Assert each page is the next expected page
// This is using a cursor, and only works if all users created_at
// is unique.
page , err = client . Users ( ctx , opt ( codersdk . UsersRequest {
2022-05-10 10:44:09 +03:00
Pagination : codersdk . Pagination {
Limit : limit ,
AfterID : afterCursor ,
},
2022-04-22 15:27:55 -05:00
}))
require . NoError ( t , err , "next cursor page" )
// Also check page by offset
offsetPage , err := client . Users ( ctx , opt ( codersdk . UsersRequest {
2022-05-10 10:44:09 +03:00
Pagination : codersdk . Pagination {
Limit : limit ,
Offset : count ,
},
2022-04-22 15:27:55 -05:00
}))
require . NoError ( t , err , "next offset page" )
2023-12-04 11:05:17 -05:00
var expected [] database . User
2022-04-22 15:27:55 -05:00
if count + limit > len ( allUsers ) {
expected = allUsers [ count :]
} else {
expected = allUsers [ count : count + limit ]
}
2023-12-04 11:05:17 -05:00
require . Equalf ( t , onlyUsernames ( page . Users ), onlyUsernames ( expected ), "next users, after=%s, limit=%d" , afterCursor , limit )
require . Equalf ( t , onlyUsernames ( offsetPage . Users ), onlyUsernames ( expected ), "offset users, offset=%d, limit=%d" , count , limit )
2022-04-22 15:27:55 -05:00
// Also check the before
prevPage , err := client . Users ( ctx , opt ( codersdk . UsersRequest {
2022-05-10 10:44:09 +03:00
Pagination : codersdk . Pagination {
Offset : count - limit ,
Limit : limit ,
},
2022-04-22 15:27:55 -05:00
}))
require . NoError ( t , err , "prev page" )
2023-12-04 11:05:17 -05:00
require . Equal ( t , onlyUsernames ( allUsers [ count - limit : count ]), onlyUsernames ( prevPage . Users ), "prev users" )
2022-11-14 17:22:57 -05:00
count += len ( page . Users )
2022-04-22 15:27:55 -05:00
}
}
2022-04-25 10:27:08 -05:00
// sortUsers sorts by (created_at, id)
func sortUsers ( users [] codersdk . User ) {
2023-08-09 14:50:26 -05:00
slices . SortFunc ( users , func ( a , b codersdk . User ) int {
return slice . Ascending ( strings . ToLower ( a . Username ), strings . ToLower ( b . Username ))
2022-04-25 10:27:08 -05:00
})
}
2023-05-08 08:59:01 -05:00
2023-12-04 11:05:17 -05:00
func sortDatabaseUsers ( users [] database . User ) {
slices . SortFunc ( users , func ( a , b database . User ) int {
return slice . Ascending ( strings . ToLower ( a . Username ), strings . ToLower ( b . Username ))
})
}
func onlyUsernames [ U codersdk . User | database . User ]( users [] U ) [] string {
var out [] string
for _ , u := range users {
switch u := ( any ( u )).( type ) {
case codersdk . User :
out = append ( out , u . Username )
case database . User :
out = append ( out , u . Username )
}
}
return out
}
2023-05-08 08:59:01 -05:00
func BenchmarkUsersMe ( b * testing . B ) {
client := coderdtest . New ( b , nil )
_ = coderdtest . CreateFirstUser ( b , client )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
b . ReportAllocs ()
b . ResetTimer ()
for i := 0 ; i < b . N ; i ++ {
_ , err := client . User ( ctx , codersdk . Me )
require . NoError ( b , err )
}
}