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"
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"
2024-10-31 17:55:42 -05:00
"github.com/coder/coder/v2/coderd/util/ptr"
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 ()
2024-02-23 17:48:24 +01:00
trialGenerated := make ( chan struct {})
entitlementsRefreshed := make ( chan struct {})
2022-11-16 17:09:49 -06:00
client := coderdtest . New ( t , & coderdtest . Options {
2024-01-16 18:19:16 -06:00
TrialGenerator : func ( context . Context , codersdk . LicensorTrialRequest ) error {
2024-02-23 17:48:24 +01:00
close ( trialGenerated )
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
2025-04-16 09:37:09 -07:00
_ = testutil . TryReceive ( ctx , t , trialGenerated )
_ = testutil . TryReceive ( ctx , t , entitlementsRefreshed )
2022-11-16 17:09:49 -06:00
})
2022-02-17 20:09:33 -08: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
})
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" ])
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!" ,
UserStatus : ptr . Ref ( codersdk . UserStatusActive ),
})
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 ()
2024-08-23 16:23:51 -05:00
user , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
OrganizationIDs : [] uuid . UUID { first . OrganizationID },
Email : "another@user.org" ,
Username : "someone-else" ,
Password : "" ,
UserLoginType : codersdk . LoginTypeNone ,
2023-08-10 20:04:35 -05:00
})
require . NoError ( t , err )
found , err := client . User ( ctx , user . ID . String ())
require . NoError ( t , err )
require . Equal ( t , found . LoginType , codersdk . LoginTypeNone )
})
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 {
2023-08-10 20:04:35 -05:00
"email" : email ,
2025-02-10 09:31:08 -06:00
"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
t . Run ( "ServiceAccount/OK" , 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 ()
user , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
OrganizationIDs : [] uuid . UUID { first . OrganizationID },
Username : "service-acct-ok" ,
UserLoginType : codersdk . LoginTypeNone ,
ServiceAccount : true ,
})
require . NoError ( t , err )
require . Equal ( t , codersdk . LoginTypeNone , user . LoginType )
require . Empty ( t , user . Email )
require . Equal ( t , "service-acct-ok" , user . Username )
require . Equal ( t , codersdk . UserStatusDormant , user . Status )
})
t . Run ( "ServiceAccount/WithEmail" , 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 : "service-acct-email" ,
Email : "should-not-have@email.com" ,
ServiceAccount : true ,
})
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
require . Equal ( t , http . StatusBadRequest , apiErr . StatusCode ())
require . Contains ( t , apiErr . Message , "Email cannot be set for service accounts" )
})
t . Run ( "ServiceAccount/WithPassword" , 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 : "service-acct-password" ,
Password : "ShouldNotHavePassword123!" ,
ServiceAccount : true ,
})
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
require . Equal ( t , http . StatusBadRequest , apiErr . StatusCode ())
require . Contains ( t , apiErr . Message , "Password cannot be set for service accounts" )
})
t . Run ( "ServiceAccount/WithInvalidLoginType" , 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 : "service-acct-login-type" ,
UserLoginType : codersdk . LoginTypePassword ,
ServiceAccount : true ,
})
var apiErr * codersdk . Error
require . ErrorAs ( t , err , & apiErr )
require . Equal ( t , http . StatusBadRequest , apiErr . StatusCode ())
require . Contains ( t , apiErr . Message , "Service accounts must use login type 'none'" )
})
t . Run ( "ServiceAccount/DefaultLoginType" , 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 ()
user , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
OrganizationIDs : [] uuid . UUID { first . OrganizationID },
Username : "service-acct-default-login" ,
ServiceAccount : true ,
})
require . NoError ( t , err )
found , err := client . User ( ctx , user . ID . String ())
require . NoError ( t , err )
require . Equal ( t , codersdk . LoginTypeNone , found . LoginType )
require . Empty ( t , found . Email )
})
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 ())
})
t . Run ( "ServiceAccount/MultipleWithoutEmail" , 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 ()
user1 , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
OrganizationIDs : [] uuid . UUID { first . OrganizationID },
Username : "service-acct-multi-1" ,
ServiceAccount : true ,
})
require . NoError ( t , err )
require . Empty ( t , user1 . Email )
user2 , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
OrganizationIDs : [] uuid . UUID { first . OrganizationID },
Username : "service-acct-multi-2" ,
ServiceAccount : true ,
})
require . NoError ( t , err )
require . Empty ( t , user2 . Email )
require . NotEqual ( t , user1 . ID , user2 . ID )
})
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" ])
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 ())
})
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
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 ())
})
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
2022-04-29 11:44:22 -05:00
t . Run ( "ByMe" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
firstUser := coderdtest . CreateFirstUser ( t , client )
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 ()
client := coderdtest . New ( t , nil )
firstUser := coderdtest . CreateFirstUser ( t , client )
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 ()
client := coderdtest . New ( t , nil )
firstUser := coderdtest . CreateFirstUser ( t , client )
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 )
require . Equal ( t , exp , user )
})
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-03-20 12:43:03 -08:00
coderdtest . UsersFilter ( setupCtx , t , client , api . Database , nil , func ( testCtx context . Context , req codersdk . UsersRequest ) [] codersdk . ReducedUser {
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 ()
t . Run ( "valid font" , func ( t * testing . T ) {
t . Parallel ()
adminClient := coderdtest . New ( t , nil )
firstUser := coderdtest . CreateFirstUser ( t , adminClient )
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 ()
adminClient := coderdtest . New ( t , nil )
firstUser := coderdtest . CreateFirstUser ( t , adminClient )
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 ()
adminClient := coderdtest . New ( t , nil )
firstUser := coderdtest . CreateFirstUser ( t , adminClient )
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 )
})
}
2025-11-28 16:50:59 +00:00
func TestUserTaskNotificationAlertDismissed ( t * testing . T ) {
t . Parallel ()
t . Run ( "defaults to false" , func ( t * testing . T ) {
t . Parallel ()
adminClient := coderdtest . New ( t , nil )
firstUser := coderdtest . CreateFirstUser ( t , adminClient )
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
// When: getting user preference settings for a user
settings , err := client . GetUserPreferenceSettings ( ctx , codersdk . Me )
require . NoError ( t , err )
// Then: the task notification alert dismissed should default to false
require . False ( t , settings . TaskNotificationAlertDismissed )
})
t . Run ( "update to true" , func ( t * testing . T ) {
t . Parallel ()
adminClient := coderdtest . New ( t , nil )
firstUser := coderdtest . CreateFirstUser ( t , adminClient )
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
// When: user dismisses the task notification alert
updated , err := client . UpdateUserPreferenceSettings ( ctx , codersdk . Me , codersdk . UpdateUserPreferenceSettingsRequest {
TaskNotificationAlertDismissed : true ,
})
require . NoError ( t , err )
// Then: the setting is updated to true
require . True ( t , updated . TaskNotificationAlertDismissed )
})
t . Run ( "update to false" , func ( t * testing . T ) {
t . Parallel ()
adminClient := coderdtest . New ( t , nil )
firstUser := coderdtest . CreateFirstUser ( t , adminClient )
client , _ := coderdtest . CreateAnotherUser ( t , adminClient , firstUser . OrganizationID )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitShort )
defer cancel ()
// Given: user has dismissed the task notification alert
_ , err := client . UpdateUserPreferenceSettings ( ctx , codersdk . Me , codersdk . UpdateUserPreferenceSettingsRequest {
TaskNotificationAlertDismissed : true ,
})
require . NoError ( t , err )
// When: the task notification alert dismissal is cleared
// (e.g., when user enables a task notification in the UI settings)
updated , err := client . UpdateUserPreferenceSettings ( ctx , codersdk . Me , codersdk . UpdateUserPreferenceSettingsRequest {
TaskNotificationAlertDismissed : false ,
})
require . NoError ( t , err )
// Then: the setting is updated to false
require . False ( t , updated . TaskNotificationAlertDismissed )
})
}
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
for {
2022-11-14 17:22:57 -05:00
if len ( page . Users ) == 0 {
2022-04-22 15:27:55 -05:00
break
}
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 )
}
}