2022-01-20 07:46:51 -06:00
package coderd_test
import (
"context"
2025-03-21 13:30:47 +01:00
"database/sql"
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
2025-03-25 14:18:06 +02:00
"github.com/coder/serpent"
2023-08-25 14:34:07 -05:00
"github.com/coder/coder/v2/coderd"
"github.com/coder/coder/v2/coderd/coderdtest/oidctest"
2024-07-30 15:37:45 +02:00
"github.com/coder/coder/v2/coderd/notifications"
2024-11-12 12:40:46 +00:00
"github.com/coder/coder/v2/coderd/notifications/notificationstest"
2024-05-15 09:46:35 -05:00
"github.com/coder/coder/v2/coderd/rbac/policy"
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
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/audit"
"github.com/coder/coder/v2/coderd/coderdtest"
"github.com/coder/coder/v2/coderd/database"
2024-12-17 09:54:54 +05:30
"github.com/coder/coder/v2/coderd/database/db2sdk"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/database/dbauthz"
2024-01-30 16:02:21 -06:00
"github.com/coder/coder/v2/coderd/database/dbfake"
2023-12-04 11:05:17 -05:00
"github.com/coder/coder/v2/coderd/database/dbgen"
2023-09-01 19:50:12 +03:00
"github.com/coder/coder/v2/coderd/database/dbtime"
2023-08-18 13:55:43 -05:00
"github.com/coder/coder/v2/coderd/rbac"
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"
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" )
2024-09-18 21:23:42 +10:00
require . True ( t , apiKey . ExpiresAt . After ( time . Now (). Add ( time . Hour * 24 * 6 )), "default tokens lasts more than 6 days" )
require . True ( t , apiKey . ExpiresAt . Before ( time . 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 )
2023-10-11 09:41:14 +04:00
require . Equal ( t , http . StatusBadRequest , 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 )
// sent[0]: "User admin" account created, "owner" notified
// sent[1]: "Member" account created, "owner" notified
// sent[2]: "Member" account created, "user admin" notified
2024-08-02 14:56:54 +02:00
// "Member" account deleted, "owner" notified
2024-11-12 12:40:46 +00:00
require . Equal ( t , notifications . TemplateUserAccountDeleted , sent [ 3 ]. TemplateID )
require . Equal ( t , firstUser . UserID , sent [ 3 ]. UserID )
require . Contains ( t , sent [ 3 ]. Targets , member . ID )
require . Equal ( t , member . Username , sent [ 3 ]. Labels [ "deleted_account_name" ])
2024-08-02 14:56:54 +02:00
// "Member" account deleted, "user admin" notified
2024-11-12 12:40:46 +00:00
require . Equal ( t , notifications . TemplateUserAccountDeleted , sent [ 4 ]. TemplateID )
require . Equal ( t , userAdmin . ID , sent [ 4 ]. UserID )
require . Contains ( t , sent [ 4 ]. Targets , member . ID )
require . Equal ( t , member . Username , sent [ 4 ]. Labels [ "deleted_account_name" ])
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 )
})
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
2024-11-12 12:40:46 +00:00
require . Equal ( t , notifications . TemplateUserAccountCreated , sent [ 0 ]. TemplateID )
require . Equal ( t , firstUser . UserID , sent [ 0 ]. UserID )
require . Contains ( t , sent [ 0 ]. Targets , userAdmin . ID )
require . Equal ( t , userAdmin . Username , sent [ 0 ]. Labels [ "created_account_name" ])
2024-07-30 15:37:45 +02:00
// "Member" account created, "owner" notified
2024-11-12 12:40:46 +00:00
require . Equal ( t , notifications . TemplateUserAccountCreated , sent [ 1 ]. TemplateID )
require . Equal ( t , firstUser . UserID , sent [ 1 ]. UserID )
require . Contains ( t , sent [ 1 ]. Targets , member . ID )
require . Equal ( t , member . Username , sent [ 1 ]. Labels [ "created_account_name" ])
2024-07-30 15:37:45 +02:00
// "Member" account created, "user admin" notified
2024-11-12 12:40:46 +00:00
require . Equal ( t , notifications . TemplateUserAccountCreated , sent [ 1 ]. TemplateID )
require . Equal ( t , userAdmin . ID , sent [ 2 ]. UserID )
require . Contains ( t , sent [ 2 ]. Targets , member . ID )
require . Equal ( t , member . Username , sent [ 2 ]. Labels [ "created_account_name" ])
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
require . Equal ( t , http . StatusBadRequest , apiErr . StatusCode ())
})
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 )
})
t . Run ( "UpdateSelfAsMember" , 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 login
2024-12-16 17:59:44 +11:00
memberClient , _ := coderdtest . CreateAnotherUser ( t , client , firstUser . 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 )
newName := coderdtest . RandomName ( t )
2024-06-04 14:17:17 +01:00
userProfile , err := memberClient . UpdateUserProfile ( ctx , codersdk . Me , codersdk . UpdateUserProfileRequest {
2024-12-16 17:59:44 +11:00
Username : newUsername ,
Name : newName ,
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 )
require . Equal ( t , newName , 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
}
2022-06-24 10:02:23 -05:00
// TestUsersFilter creates a set of users to run various filters against for testing.
func TestUsersFilter ( t * testing . T ) {
t . Parallel ()
2023-06-22 15:24:48 -05:00
client , _ , api := coderdtest . NewWithAPI ( t , & coderdtest . Options { IncludeProvisionerDaemon : true })
2022-06-24 10:02:23 -05:00
first := 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
firstUser , err := client . User ( ctx , codersdk . Me )
2022-06-24 10:02:23 -05:00
require . NoError ( t , err , "fetch me" )
2023-06-22 15:24:48 -05:00
// Noon on Jan 18 is the "now" for this test for last_seen timestamps.
// All these values are equal
// 2023-01-18T12:00:00Z (UTC)
// 2023-01-18T07:00:00-05:00 (America/New_York)
// 2023-01-18T13:00:00+01:00 (Europe/Madrid)
// 2023-01-16T00:00:00+12:00 (Asia/Anadyr)
lastSeenNow := time . Date ( 2023 , 1 , 18 , 12 , 0 , 0 , 0 , time . UTC )
2022-06-24 10:02:23 -05:00
users := make ([] codersdk . User , 0 )
users = append ( users , firstUser )
for i := 0 ; i < 15 ; i ++ {
2024-06-11 08:55:28 -05:00
roles := [] rbac . RoleIdentifier {}
2022-06-24 10:02:23 -05:00
if i % 2 == 0 {
2022-08-31 11:26:36 -04:00
roles = append ( roles , rbac . RoleTemplateAdmin (), rbac . RoleUserAdmin ())
2022-06-24 10:02:23 -05:00
}
if i % 3 == 0 {
2024-06-11 08:55:28 -05:00
roles = append ( roles , rbac . RoleAuditor ())
2022-06-24 10:02:23 -05:00
}
2023-06-22 15:24:48 -05:00
userClient , userData := coderdtest . CreateAnotherUser ( t , client , first . OrganizationID , roles ... )
// Set the last seen for each user to a unique day
// nolint:gocritic // Unit test
_ , err := api . Database . UpdateUserLastSeenAt ( dbauthz . AsSystemRestricted ( ctx ), database . UpdateUserLastSeenAtParams {
ID : userData . ID ,
LastSeenAt : lastSeenNow . Add ( - 1 * time . Hour * 24 * time . Duration ( i )),
UpdatedAt : time . Now (),
})
require . NoError ( t , err , "set a last seen" )
2022-08-09 20:17:00 +03:00
user , err := userClient . User ( ctx , codersdk . Me )
2022-06-24 10:02:23 -05:00
require . NoError ( t , err , "fetch me" )
if i % 4 == 0 {
2022-08-09 20:17:00 +03:00
user , err = client . UpdateUserStatus ( ctx , user . ID . String (), codersdk . UserStatusSuspended )
2022-06-24 10:02:23 -05:00
require . NoError ( t , err , "suspend user" )
}
2022-06-24 19:55:28 -04:00
if i % 5 == 0 {
2022-08-09 20:17:00 +03:00
user , err = client . UpdateUserProfile ( ctx , user . ID . String (), codersdk . UpdateUserProfileRequest {
2022-06-24 19:55:28 -04:00
Username : strings . ToUpper ( user . Username ),
})
require . NoError ( t , err , "update username to uppercase" )
}
2022-06-24 10:02:23 -05:00
users = append ( users , user )
}
2024-12-17 09:54:54 +05:30
// Add users with different creation dates for testing date filters
for i := 0 ; i < 3 ; i ++ {
// nolint:gocritic // Using system context is necessary to seed data in tests
user1 , err := api . Database . InsertUser ( dbauthz . AsSystemRestricted ( ctx ), database . InsertUserParams {
ID : uuid . New (),
Email : fmt . Sprintf ( "before%d@coder.com" , i ),
Username : fmt . Sprintf ( "before%d" , i ),
LoginType : database . LoginTypeNone ,
Status : string ( codersdk . UserStatusActive ),
RBACRoles : [] string { codersdk . RoleMember },
CreatedAt : dbtime . Time ( time . Date ( 2022 , 12 , 15 + i , 12 , 0 , 0 , 0 , time . UTC )),
})
require . NoError ( t , err )
// The expected timestamps must be parsed from strings to compare equal during `ElementsMatch`
sdkUser1 := db2sdk . User ( user1 , nil )
sdkUser1 . CreatedAt , err = time . Parse ( time . RFC3339 , sdkUser1 . CreatedAt . Format ( time . RFC3339 ))
require . NoError ( t , err )
sdkUser1 . UpdatedAt , err = time . Parse ( time . RFC3339 , sdkUser1 . UpdatedAt . Format ( time . RFC3339 ))
require . NoError ( t , err )
sdkUser1 . LastSeenAt , err = time . Parse ( time . RFC3339 , sdkUser1 . LastSeenAt . Format ( time . RFC3339 ))
require . NoError ( t , err )
users = append ( users , sdkUser1 )
// nolint:gocritic //Using system context is necessary to seed data in tests
user2 , err := api . Database . InsertUser ( dbauthz . AsSystemRestricted ( ctx ), database . InsertUserParams {
ID : uuid . New (),
Email : fmt . Sprintf ( "during%d@coder.com" , i ),
Username : fmt . Sprintf ( "during%d" , i ),
LoginType : database . LoginTypeNone ,
Status : string ( codersdk . UserStatusActive ),
RBACRoles : [] string { codersdk . RoleOwner },
CreatedAt : dbtime . Time ( time . Date ( 2023 , 1 , 15 + i , 12 , 0 , 0 , 0 , time . UTC )),
})
require . NoError ( t , err )
sdkUser2 := db2sdk . User ( user2 , nil )
sdkUser2 . CreatedAt , err = time . Parse ( time . RFC3339 , sdkUser2 . CreatedAt . Format ( time . RFC3339 ))
require . NoError ( t , err )
sdkUser2 . UpdatedAt , err = time . Parse ( time . RFC3339 , sdkUser2 . UpdatedAt . Format ( time . RFC3339 ))
require . NoError ( t , err )
sdkUser2 . LastSeenAt , err = time . Parse ( time . RFC3339 , sdkUser2 . LastSeenAt . Format ( time . RFC3339 ))
require . NoError ( t , err )
users = append ( users , sdkUser2 )
// nolint:gocritic // Using system context is necessary to seed data in tests
user3 , err := api . Database . InsertUser ( dbauthz . AsSystemRestricted ( ctx ), database . InsertUserParams {
ID : uuid . New (),
Email : fmt . Sprintf ( "after%d@coder.com" , i ),
Username : fmt . Sprintf ( "after%d" , i ),
LoginType : database . LoginTypeNone ,
Status : string ( codersdk . UserStatusActive ),
RBACRoles : [] string { codersdk . RoleOwner },
CreatedAt : dbtime . Time ( time . Date ( 2023 , 2 , 15 + i , 12 , 0 , 0 , 0 , time . UTC )),
})
require . NoError ( t , err )
sdkUser3 := db2sdk . User ( user3 , nil )
sdkUser3 . CreatedAt , err = time . Parse ( time . RFC3339 , sdkUser3 . CreatedAt . Format ( time . RFC3339 ))
require . NoError ( t , err )
sdkUser3 . UpdatedAt , err = time . Parse ( time . RFC3339 , sdkUser3 . UpdatedAt . Format ( time . RFC3339 ))
require . NoError ( t , err )
sdkUser3 . LastSeenAt , err = time . Parse ( time . RFC3339 , sdkUser3 . LastSeenAt . Format ( time . RFC3339 ))
require . NoError ( t , err )
users = append ( users , sdkUser3 )
}
2022-06-24 10:02:23 -05:00
// --- Setup done ---
testCases := [] struct {
Name string
Filter codersdk . UsersRequest
// If FilterF is true, we include it in the expected results
FilterF func ( f codersdk . UsersRequest , user codersdk . User ) bool
}{
{
Name : "All" ,
Filter : codersdk . UsersRequest {
Status : codersdk . UserStatusSuspended + "," + codersdk . UserStatusActive ,
},
FilterF : func ( _ codersdk . UsersRequest , u codersdk . User ) bool {
return true
},
},
{
Name : "Active" ,
Filter : codersdk . UsersRequest {
Status : codersdk . UserStatusActive ,
},
FilterF : func ( _ codersdk . UsersRequest , u codersdk . User ) bool {
return u . Status == codersdk . UserStatusActive
},
},
2022-06-24 19:55:28 -04:00
{
Name : "ActiveUppercase" ,
Filter : codersdk . UsersRequest {
Status : "ACTIVE" ,
},
FilterF : func ( _ codersdk . UsersRequest , u codersdk . User ) bool {
return u . Status == codersdk . UserStatusActive
},
},
2022-06-24 10:02:23 -05:00
{
Name : "Suspended" ,
Filter : codersdk . UsersRequest {
Status : codersdk . UserStatusSuspended ,
},
FilterF : func ( _ codersdk . UsersRequest , u codersdk . User ) bool {
return u . Status == codersdk . UserStatusSuspended
},
},
{
Name : "NameContains" ,
Filter : codersdk . UsersRequest {
Search : "a" ,
},
FilterF : func ( _ codersdk . UsersRequest , u codersdk . User ) bool {
2022-06-24 19:55:28 -04:00
return ( strings . ContainsAny ( u . Username , "aA" ) || strings . ContainsAny ( u . Email , "aA" ))
2022-06-24 10:02:23 -05:00
},
},
{
Name : "Admins" ,
Filter : codersdk . UsersRequest {
2024-06-11 08:55:28 -05:00
Role : codersdk . RoleOwner ,
2022-06-24 10:02:23 -05:00
Status : codersdk . UserStatusSuspended + "," + codersdk . UserStatusActive ,
},
FilterF : func ( _ codersdk . UsersRequest , u codersdk . User ) bool {
for _ , r := range u . Roles {
2024-06-11 08:55:28 -05:00
if r . Name == codersdk . RoleOwner {
2022-06-24 10:02:23 -05:00
return true
}
}
return false
},
},
2022-06-24 19:55:28 -04:00
{
Name : "AdminsUppercase" ,
Filter : codersdk . UsersRequest {
2022-08-15 14:40:19 -05:00
Role : "OWNER" ,
2022-06-24 19:55:28 -04:00
Status : codersdk . UserStatusSuspended + "," + codersdk . UserStatusActive ,
},
FilterF : func ( _ codersdk . UsersRequest , u codersdk . User ) bool {
for _ , r := range u . Roles {
2024-06-11 08:55:28 -05:00
if r . Name == codersdk . RoleOwner {
2022-06-24 19:55:28 -04:00
return true
}
}
return false
},
},
{
Name : "Members" ,
Filter : codersdk . UsersRequest {
2024-06-11 08:55:28 -05:00
Role : codersdk . RoleMember ,
2022-06-24 19:55:28 -04:00
Status : codersdk . UserStatusSuspended + "," + codersdk . UserStatusActive ,
},
FilterF : func ( _ codersdk . UsersRequest , u codersdk . User ) bool {
return true
},
},
2022-06-24 10:02:23 -05:00
{
Name : "SearchQuery" ,
Filter : codersdk . UsersRequest {
2022-08-15 14:40:19 -05:00
SearchQuery : "i role:owner status:active" ,
2022-06-24 10:02:23 -05:00
},
FilterF : func ( _ codersdk . UsersRequest , u codersdk . User ) bool {
for _ , r := range u . Roles {
2024-06-11 08:55:28 -05:00
if r . Name == codersdk . RoleOwner {
2022-06-24 19:55:28 -04:00
return ( strings . ContainsAny ( u . Username , "iI" ) || strings . ContainsAny ( u . Email , "iI" )) &&
u . Status == codersdk . UserStatusActive
}
}
return false
},
},
{
Name : "SearchQueryInsensitive" ,
Filter : codersdk . UsersRequest {
2022-08-15 14:40:19 -05:00
SearchQuery : "i Role:Owner STATUS:Active" ,
2022-06-24 19:55:28 -04:00
},
FilterF : func ( _ codersdk . UsersRequest , u codersdk . User ) bool {
for _ , r := range u . Roles {
2024-06-11 08:55:28 -05:00
if r . Name == codersdk . RoleOwner {
2022-06-24 19:55:28 -04:00
return ( strings . ContainsAny ( u . Username , "iI" ) || strings . ContainsAny ( u . Email , "iI" )) &&
2022-06-24 10:02:23 -05:00
u . Status == codersdk . UserStatusActive
}
}
return false
},
},
2023-06-22 15:24:48 -05:00
{
Name : "LastSeenBeforeNow" ,
Filter : codersdk . UsersRequest {
SearchQuery : `last_seen_before:"2023-01-16T00:00:00+12:00"` ,
},
FilterF : func ( _ codersdk . UsersRequest , u codersdk . User ) bool {
return u . LastSeenAt . Before ( lastSeenNow )
},
},
{
Name : "LastSeenLastWeek" ,
Filter : codersdk . UsersRequest {
SearchQuery : `last_seen_before:"2023-01-14T23:59:59Z" last_seen_after:"2023-01-08T00:00:00Z"` ,
},
FilterF : func ( _ codersdk . UsersRequest , u codersdk . User ) bool {
start := time . Date ( 2023 , 1 , 8 , 0 , 0 , 0 , 0 , time . UTC )
end := time . Date ( 2023 , 1 , 14 , 23 , 59 , 59 , 0 , time . UTC )
return u . LastSeenAt . Before ( end ) && u . LastSeenAt . After ( start )
},
},
2024-12-17 09:54:54 +05:30
{
Name : "CreatedAtBefore" ,
Filter : codersdk . UsersRequest {
SearchQuery : `created_before:"2023-01-31T23:59:59Z"` ,
},
FilterF : func ( _ codersdk . UsersRequest , u codersdk . User ) bool {
end := time . Date ( 2023 , 1 , 31 , 23 , 59 , 59 , 0 , time . UTC )
return u . CreatedAt . Before ( end )
},
},
{
Name : "CreatedAtAfter" ,
Filter : codersdk . UsersRequest {
SearchQuery : `created_after:"2023-01-01T00:00:00Z"` ,
},
FilterF : func ( _ codersdk . UsersRequest , u codersdk . User ) bool {
start := time . Date ( 2023 , 1 , 1 , 0 , 0 , 0 , 0 , time . UTC )
return u . CreatedAt . After ( start )
},
},
{
Name : "CreatedAtRange" ,
Filter : codersdk . UsersRequest {
SearchQuery : `created_after:"2023-01-01T00:00:00Z" created_before:"2023-01-31T23:59:59Z"` ,
},
FilterF : func ( _ codersdk . UsersRequest , u codersdk . User ) bool {
start := time . Date ( 2023 , 1 , 1 , 0 , 0 , 0 , 0 , time . UTC )
end := time . Date ( 2023 , 1 , 31 , 23 , 59 , 59 , 0 , time . UTC )
return u . CreatedAt . After ( start ) && u . CreatedAt . Before ( end )
},
},
2022-06-24 10:02:23 -05:00
}
for _ , c := range testCases {
t . Run ( c . Name , func ( t * testing . T ) {
t . Parallel ()
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
matched , err := client . Users ( ctx , c . Filter )
2022-06-24 10:02:23 -05:00
require . NoError ( t , err , "fetch workspaces" )
exp := make ([] codersdk . User , 0 )
for _ , made := range users {
match := c . FilterF ( c . Filter , made )
if match {
exp = append ( exp , made )
}
}
2024-12-17 09:54:54 +05:30
2024-06-26 09:00:42 +01:00
require . ElementsMatch ( t , exp , matched . Users , "expected users returned" )
2022-06-24 10:02:23 -05:00
})
}
}
2022-04-18 12:19:47 -05:00
func TestGetUsers ( t * testing . T ) {
t . Parallel ()
2022-04-29 08:29:53 -05:00
t . Run ( "AllUsers" , 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
client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
Email : "alice@email.com" ,
Username : "alice" ,
Password : "MySecurePassword!" ,
OrganizationIDs : [] uuid . UUID { user . OrganizationID },
2022-04-29 08:29:53 -05:00
})
// No params is all users
2022-11-14 17:22:57 -05:00
res , err := client . Users ( ctx , codersdk . UsersRequest {})
2022-04-29 08:29:53 -05:00
require . NoError ( t , err )
2022-11-14 17:22:57 -05:00
require . Len ( t , res . Users , 2 )
require . Len ( t , res . Users [ 0 ]. OrganizationIDs , 1 )
2022-04-29 08:29:53 -05:00
})
t . Run ( "ActiveUsers" , func ( t * testing . T ) {
t . Parallel ()
2022-05-16 15:29:27 -05:00
active := make ([] codersdk . User , 0 )
2022-04-29 08:29:53 -05:00
client := coderdtest . New ( t , nil )
first := coderdtest . CreateFirstUser ( t , client )
2022-05-16 15:29:27 -05:00
2022-08-09 20:17:00 +03:00
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
firstUser , err := client . User ( ctx , first . UserID . String ())
2022-05-16 15:29:27 -05:00
require . NoError ( t , err , "" )
active = append ( active , firstUser )
// Alice will be suspended
2024-08-23 16:23:51 -05:00
alice , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
Email : "alice@email.com" ,
Username : "alice" ,
Password : "MySecurePassword!" ,
OrganizationIDs : [] uuid . UUID { first . OrganizationID },
2022-04-29 08:29:53 -05:00
})
require . NoError ( t , err )
2023-08-02 16:31:25 +02:00
_ , err = client . UpdateUserStatus ( ctx , alice . Username , codersdk . UserStatusSuspended )
require . NoError ( t , err )
// Tom will be active
2024-08-23 16:23:51 -05:00
tom , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
Email : "tom@email.com" ,
Username : "tom" ,
Password : "MySecurePassword!" ,
OrganizationIDs : [] uuid . UUID { first . OrganizationID },
2022-04-29 08:29:53 -05:00
})
require . NoError ( t , err )
2023-08-02 16:31:25 +02:00
tom , err = client . UpdateUserStatus ( ctx , tom . Username , codersdk . UserStatusActive )
2022-04-29 08:29:53 -05:00
require . NoError ( t , err )
2023-08-02 16:31:25 +02:00
active = append ( active , tom )
2022-04-29 08:29:53 -05:00
2022-11-14 17:22:57 -05:00
res , err := client . Users ( ctx , codersdk . UsersRequest {
2022-06-24 10:02:23 -05:00
Status : codersdk . UserStatusActive ,
2022-04-29 08:29:53 -05:00
})
require . NoError ( t , err )
2022-11-14 17:22:57 -05:00
require . ElementsMatch ( t , active , res . Users )
2022-04-18 12:19:47 -05:00
})
2025-03-21 13:30:47 +01:00
t . Run ( "GithubComUserID" , func ( t * testing . T ) {
t . Parallel ()
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
client , db := coderdtest . NewWithDatabase ( t , nil )
first := coderdtest . CreateFirstUser ( t , client )
_ = dbgen . User ( t , db , database . User {
Email : "test2@coder.com" ,
Username : "test2" ,
})
// nolint:gocritic // Unit test
err := db . UpdateUserGithubComUserID ( dbauthz . AsSystemRestricted ( ctx ), database . UpdateUserGithubComUserIDParams {
ID : first . UserID ,
GithubComUserID : sql . NullInt64 {
Int64 : 123 ,
Valid : true ,
},
})
require . NoError ( t , err )
res , err := client . Users ( ctx , codersdk . UsersRequest {
SearchQuery : "github_com_user_id:123" ,
})
require . NoError ( t , err )
require . Len ( t , res . Users , 1 )
require . Equal ( t , res . Users [ 0 ]. ID , first . UserID )
})
2025-04-08 23:59:41 -04:00
t . Run ( "LoginTypeNoneFilter" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
first := coderdtest . CreateFirstUser ( t , client )
ctx := testutil . Context ( t , testutil . WaitLong )
_ , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
Email : "bob@email.com" ,
Username : "bob" ,
OrganizationIDs : [] uuid . UUID { first . OrganizationID },
UserLoginType : codersdk . LoginTypeNone ,
})
require . NoError ( t , err )
res , err := client . Users ( ctx , codersdk . UsersRequest {
LoginType : [] codersdk . LoginType { codersdk . LoginTypeNone },
})
require . NoError ( t , err )
require . Len ( t , res . Users , 1 )
require . Equal ( t , res . Users [ 0 ]. LoginType , codersdk . LoginTypeNone )
})
t . Run ( "LoginTypeMultipleFilter" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
first := coderdtest . CreateFirstUser ( t , client )
ctx := testutil . Context ( t , testutil . WaitLong )
filtered := make ([] codersdk . User , 0 )
bob , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
Email : "bob@email.com" ,
Username : "bob" ,
OrganizationIDs : [] uuid . UUID { first . OrganizationID },
UserLoginType : codersdk . LoginTypeNone ,
})
require . NoError ( t , err )
filtered = append ( filtered , bob )
charlie , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
Email : "charlie@email.com" ,
Username : "charlie" ,
OrganizationIDs : [] uuid . UUID { first . OrganizationID },
UserLoginType : codersdk . LoginTypeGithub ,
})
require . NoError ( t , err )
filtered = append ( filtered , charlie )
res , err := client . Users ( ctx , codersdk . UsersRequest {
LoginType : [] codersdk . LoginType { codersdk . LoginTypeNone , codersdk . LoginTypeGithub },
})
require . NoError ( t , err )
require . Len ( t , res . Users , 2 )
require . ElementsMatch ( t , filtered , res . Users )
})
t . Run ( "DormantUserWithLoginTypeNone" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , nil )
first := coderdtest . CreateFirstUser ( t , client )
ctx := testutil . Context ( t , testutil . WaitLong )
_ , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
Email : "bob@email.com" ,
Username : "bob" ,
OrganizationIDs : [] uuid . UUID { first . OrganizationID },
UserLoginType : codersdk . LoginTypeNone ,
})
require . NoError ( t , err )
_ , err = client . UpdateUserStatus ( ctx , "bob" , codersdk . UserStatusSuspended )
require . NoError ( t , err )
res , err := client . Users ( ctx , codersdk . UsersRequest {
Status : codersdk . UserStatusSuspended ,
LoginType : [] codersdk . LoginType { codersdk . LoginTypeNone , codersdk . LoginTypeGithub },
})
require . NoError ( t , err )
require . Len ( t , res . Users , 1 )
require . Equal ( t , res . Users [ 0 ]. Username , "bob" )
require . Equal ( t , res . Users [ 0 ]. Status , codersdk . UserStatusSuspended )
require . Equal ( t , res . Users [ 0 ]. LoginType , codersdk . LoginTypeNone )
})
t . Run ( "LoginTypeOidcFromMultipleUser" , func ( t * testing . T ) {
t . Parallel ()
client := coderdtest . New ( t , & coderdtest . Options {
OIDCConfig : & coderd . OIDCConfig {
AllowSignups : true ,
},
})
first := coderdtest . CreateFirstUser ( t , client )
ctx := testutil . Context ( t , testutil . WaitLong )
_ , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
Email : "bob@email.com" ,
Username : "bob" ,
OrganizationIDs : [] uuid . UUID { first . OrganizationID },
UserLoginType : codersdk . LoginTypeOIDC ,
})
require . NoError ( t , err )
for i := range 5 {
_ , err := client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
Email : fmt . Sprintf ( "%d@coder.com" , i ),
Username : fmt . Sprintf ( "user%d" , i ),
OrganizationIDs : [] uuid . UUID { first . OrganizationID },
UserLoginType : codersdk . LoginTypeNone ,
})
require . NoError ( t , err )
}
res , err := client . Users ( ctx , codersdk . UsersRequest {
LoginType : [] codersdk . LoginType { codersdk . LoginTypeOIDC },
})
require . NoError ( t , err )
require . Len ( t , res . Users , 1 )
require . Equal ( t , res . Users [ 0 ]. Username , "bob" )
require . Equal ( t , res . Users [ 0 ]. LoginType , codersdk . LoginTypeOIDC )
})
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 )
first := 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
2022-11-14 17:22:57 -05:00
_ , err := client . User ( ctx , first . UserID . String ())
require . NoError ( t , err , "" )
2024-08-23 16:23:51 -05:00
_ , err = client . CreateUserWithOrgs ( ctx , codersdk . CreateUserRequestWithOrgs {
Email : "alice@email.com" ,
Username : "alice" ,
Password : "MySecurePassword!" ,
OrganizationIDs : [] uuid . UUID { first . OrganizationID },
2022-11-08 10:58:44 -05:00
})
2022-11-14 17:22:57 -05:00
require . NoError ( t , err )
2022-11-08 10:58:44 -05:00
2022-11-14 17:22:57 -05:00
res , err := client . Users ( ctx , codersdk . UsersRequest {})
require . NoError ( t , err )
require . Len ( t , res . Users , 2 )
require . Equal ( t , res . Count , 2 )
2022-11-08 10:58:44 -05:00
2022-11-14 17:22:57 -05:00
res , err = client . Users ( ctx , codersdk . UsersRequest {
Pagination : codersdk . Pagination {
Limit : 1 ,
},
2022-11-08 10:58:44 -05:00
})
2022-11-14 17:22:57 -05:00
require . NoError ( t , err )
require . Len ( t , res . Users , 1 )
require . Equal ( t , res . Count , 2 )
res , err = client . Users ( ctx , codersdk . UsersRequest {
Pagination : codersdk . Pagination {
Offset : 1 ,
},
})
require . NoError ( t , err )
require . Len ( t , res . Users , 1 )
require . Equal ( t , res . Count , 2 )
// if offset is higher than the count postgres returns an empty array
2023-07-26 10:33:48 -04:00
// and not an ErrNoRows error.
2022-11-14 17:22:57 -05:00
res , err = client . Users ( ctx , codersdk . UsersRequest {
Pagination : codersdk . Pagination {
Offset : 3 ,
},
})
require . NoError ( t , err )
require . Len ( t , res . Users , 0 )
require . Equal ( t , res . Count , 0 )
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 )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
// given
initial , err := client . GetUserAppearanceSettings ( ctx , "me" )
require . NoError ( t , err )
require . Equal ( t , codersdk . TerminalFontName ( "" ), initial . TerminalFont )
// when
updated , err := client . UpdateUserAppearanceSettings ( ctx , "me" , codersdk . UpdateUserAppearanceSettingsRequest {
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 )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
// given
initial , err := client . GetUserAppearanceSettings ( ctx , "me" )
require . NoError ( t , err )
require . Equal ( t , codersdk . TerminalFontName ( "" ), initial . TerminalFont )
// when
_ , err = client . UpdateUserAppearanceSettings ( ctx , "me" , codersdk . UpdateUserAppearanceSettingsRequest {
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 )
ctx , cancel := context . WithTimeout ( context . Background (), testutil . WaitLong )
defer cancel ()
// given
initial , err := client . GetUserAppearanceSettings ( ctx , "me" )
require . NoError ( t , err )
require . Equal ( t , codersdk . TerminalFontName ( "" ), initial . TerminalFont )
// when
_ , err = client . UpdateUserAppearanceSettings ( ctx , "me" , codersdk . UpdateUserAppearanceSettingsRequest {
ThemePreference : "light" ,
TerminalFont : "" ,
})
// then
require . Error ( t , err )
})
}
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 )
require . Equal ( t , http . StatusBadRequest , apiErr . StatusCode ())
// 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 )
}
}