470 lines
14 KiB
Go
470 lines
14 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
// TestUpdateUserMaxDevices tests the admin endpoint for updating user device cap
|
|
func TestUpdateUserMaxDevices(t *testing.T) {
|
|
setup := setupTestServer(t)
|
|
|
|
// Create test user with admin role
|
|
loginTestUser(t, setup.Server, setup.DB)
|
|
adminUserID := getTestUserID(t, setup.DB)
|
|
adminToken := getAdminToken(t, setup.Server, adminUserID)
|
|
|
|
// Create a test user
|
|
userID := createTestUserForMaxDevices(t, setup.Server, adminToken)
|
|
|
|
tests := []struct {
|
|
name string
|
|
maxDevices int32
|
|
expectedStatus int
|
|
expectedBody string
|
|
}{
|
|
{
|
|
name: "Update to 5 devices",
|
|
maxDevices: 5,
|
|
expectedStatus: http.StatusOK,
|
|
expectedBody: `{"message":"max devices updated"}`,
|
|
},
|
|
{
|
|
name: "Update to 10 devices (default)",
|
|
maxDevices: 10,
|
|
expectedStatus: http.StatusOK,
|
|
expectedBody: `{"message":"max devices updated"}`,
|
|
},
|
|
{
|
|
name: "Update to 50 devices",
|
|
maxDevices: 50,
|
|
expectedStatus: http.StatusOK,
|
|
expectedBody: `{"message":"max devices updated"}`,
|
|
},
|
|
{
|
|
name: "Update to 100 devices (maximum)",
|
|
maxDevices: 100,
|
|
expectedStatus: http.StatusOK,
|
|
expectedBody: `{"message":"max devices updated"}`,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
payload := map[string]interface{}{
|
|
"max_devices": tt.maxDevices,
|
|
}
|
|
jsonData, _ := json.Marshal(payload)
|
|
|
|
req, _ := http.NewRequest("PUT", setup.Server.URL+"/api/auth/users/"+userID.String()+"/max-devices", bytes.NewBuffer(jsonData))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("Authorization", "Bearer "+adminToken)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, tt.expectedStatus, resp.StatusCode, "expected status code")
|
|
|
|
body := new(bytes.Buffer)
|
|
body.ReadFrom(resp.Body)
|
|
// Trim trailing whitespace/newline from response body
|
|
assert.Equal(t, tt.expectedBody, strings.TrimSpace(body.String()), "expected response body")
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestUpdateUserMaxDevicesValidation tests validation of max_devices parameter
|
|
func TestUpdateUserMaxDevicesValidation(t *testing.T) {
|
|
setup := setupTestServer(t)
|
|
|
|
// Create admin user and get token
|
|
adminToken := loginTestUser(t, setup.Server, setup.DB)
|
|
createAdminUser(t, setup.Server, adminToken)
|
|
adminUserID := getTestUserID(t, setup.DB)
|
|
adminToken = getAdminToken(t, setup.Server, adminUserID)
|
|
|
|
// Create test user
|
|
userID := createTestUserForMaxDevices(t, setup.Server, adminToken)
|
|
|
|
tests := []struct {
|
|
name string
|
|
maxDevices int32
|
|
expectedStatus int
|
|
}{
|
|
{
|
|
name: "Zero devices (below minimum)",
|
|
maxDevices: 0,
|
|
expectedStatus: http.StatusBadRequest,
|
|
},
|
|
{
|
|
name: "Negative devices",
|
|
maxDevices: -1,
|
|
expectedStatus: http.StatusBadRequest,
|
|
},
|
|
{
|
|
name: "101 devices (above maximum)",
|
|
maxDevices: 101,
|
|
expectedStatus: http.StatusBadRequest,
|
|
},
|
|
{
|
|
name: "1000 devices (far above maximum)",
|
|
maxDevices: 1000,
|
|
expectedStatus: http.StatusBadRequest,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
payload := map[string]interface{}{
|
|
"max_devices": tt.maxDevices,
|
|
}
|
|
jsonData, _ := json.Marshal(payload)
|
|
|
|
req, _ := http.NewRequest("PUT", setup.Server.URL+"/api/auth/users/"+userID.String()+"/max-devices", bytes.NewBuffer(jsonData))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("Authorization", "Bearer "+adminToken)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, tt.expectedStatus, resp.StatusCode, "expected validation error")
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestUpdateUserMaxDevicesAuth tests authentication requirements
|
|
func TestUpdateUserMaxDevicesAuth(t *testing.T) {
|
|
setup := setupTestServer(t)
|
|
|
|
// Create admin user
|
|
adminToken := loginTestUser(t, setup.Server, setup.DB)
|
|
createAdminUser(t, setup.Server, adminToken)
|
|
adminUserID := getTestUserID(t, setup.DB)
|
|
adminToken = getAdminToken(t, setup.Server, adminUserID)
|
|
|
|
// Create regular user
|
|
userID := createTestUserForMaxDevices(t, setup.Server, adminToken)
|
|
|
|
t.Run("No authorization", func(t *testing.T) {
|
|
payload := map[string]interface{}{
|
|
"max_devices": 10,
|
|
}
|
|
jsonData, _ := json.Marshal(payload)
|
|
|
|
req, _ := http.NewRequest("PUT", setup.Server.URL+"/api/auth/users/"+userID.String()+"/max-devices", bytes.NewBuffer(jsonData))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, http.StatusUnauthorized, resp.StatusCode)
|
|
})
|
|
|
|
t.Run("Non-admin user", func(t *testing.T) {
|
|
// Create another regular user and get their token
|
|
_ = createTestUserForMaxDevices(t, setup.Server, adminToken)
|
|
// Login as the maxdevices user (who is a regular user, not admin)
|
|
regularToken := loginTestUserByCredentials(t, setup.Server, "maxdevices@example.com", "Test@Pass123!")
|
|
require.NotEmpty(t, regularToken, "Failed to login as regular user")
|
|
|
|
payload := map[string]interface{}{
|
|
"max_devices": 10,
|
|
}
|
|
jsonData, _ := json.Marshal(payload)
|
|
|
|
req, _ := http.NewRequest("PUT", setup.Server.URL+"/api/auth/users/"+userID.String()+"/max-devices", bytes.NewBuffer(jsonData))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("Authorization", "Bearer "+regularToken)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, http.StatusForbidden, resp.StatusCode)
|
|
})
|
|
}
|
|
|
|
// TestUpdateUserMaxDevicesNonExistentUser tests with non-existent user ID
|
|
func TestUpdateUserMaxDevicesNonExistentUser(t *testing.T) {
|
|
setup := setupTestServer(t)
|
|
|
|
// Create admin user
|
|
adminToken := loginTestUser(t, setup.Server, setup.DB)
|
|
createAdminUser(t, setup.Server, adminToken)
|
|
adminUserID := getTestUserID(t, setup.DB)
|
|
adminToken = getAdminToken(t, setup.Server, adminUserID)
|
|
|
|
// Use a non-existent user ID
|
|
nonExistentUserID := uuid.New()
|
|
|
|
payload := map[string]interface{}{
|
|
"max_devices": 10,
|
|
}
|
|
jsonData, _ := json.Marshal(payload)
|
|
|
|
req, _ := http.NewRequest("PUT", setup.Server.URL+"/api/auth/users/"+nonExistentUserID.String()+"/max-devices", bytes.NewBuffer(jsonData))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("Authorization", "Bearer "+adminToken)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
// Should return 500 or 404 depending on implementation
|
|
assert.True(t, resp.StatusCode == http.StatusInternalServerError || resp.StatusCode == http.StatusNotFound)
|
|
}
|
|
|
|
// TestUpdateUserMaxDevicesMissingUserID tests with missing user ID in URL
|
|
func TestUpdateUserMaxDevicesMissingUserID(t *testing.T) {
|
|
setup := setupTestServer(t)
|
|
|
|
// Create admin user
|
|
adminToken := loginTestUser(t, setup.Server, setup.DB)
|
|
createAdminUser(t, setup.Server, adminToken)
|
|
adminUserID := getTestUserID(t, setup.DB)
|
|
adminToken = getAdminToken(t, setup.Server, adminUserID)
|
|
|
|
payload := map[string]interface{}{
|
|
"max_devices": 10,
|
|
}
|
|
jsonData, _ := json.Marshal(payload)
|
|
|
|
// Missing user ID in URL
|
|
req, _ := http.NewRequest("PUT", setup.Server.URL+"/api/auth/users//max-devices", bytes.NewBuffer(jsonData))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("Authorization", "Bearer "+adminToken)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
|
|
}
|
|
|
|
// TestListUsersIncludesMaxDevices tests that List Users returns max_devices field
|
|
func TestListUsersIncludesMaxDevices(t *testing.T) {
|
|
setup := setupTestServer(t)
|
|
|
|
// Create admin user
|
|
adminToken := loginTestUser(t, setup.Server, setup.DB)
|
|
createAdminUser(t, setup.Server, adminToken)
|
|
adminUserID := getTestUserID(t, setup.DB)
|
|
adminToken = getAdminToken(t, setup.Server, adminUserID)
|
|
|
|
req, _ := http.NewRequest("GET", setup.Server.URL+"/api/auth/users", nil)
|
|
req.Header.Set("Authorization", "Bearer "+adminToken)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
assert.Equal(t, http.StatusOK, resp.StatusCode)
|
|
|
|
var users []map[string]interface{}
|
|
json.NewDecoder(resp.Body).Decode(&users)
|
|
|
|
// Verify max_devices and device_count fields are present in response
|
|
if len(users) > 0 {
|
|
_, hasMaxDevices := users[0]["max_devices"]
|
|
assert.True(t, hasMaxDevices, "max_devices field should be present in user list")
|
|
|
|
_, hasDeviceCount := users[0]["device_count"]
|
|
assert.True(t, hasDeviceCount, "device_count field should be present in user list")
|
|
}
|
|
}
|
|
|
|
// Helper function to create admin user
|
|
func createAdminUser(t *testing.T, ts *httptest.Server, token string) {
|
|
createUserPayload := map[string]interface{}{
|
|
"email": "admin@example.com",
|
|
"username": "adminuser",
|
|
"password": "Admin@Pass123!",
|
|
"first_name": "Admin",
|
|
"last_name": "User",
|
|
"role": "admin",
|
|
}
|
|
|
|
jsonData, _ := json.Marshal(createUserPayload)
|
|
req, _ := http.NewRequest("POST", setup.Server.URL+"/api/auth/register", bytes.NewBuffer(jsonData))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
|
|
client := &http.Client{}
|
|
resp, _ := client.Do(req)
|
|
resp.Body.Close()
|
|
}
|
|
|
|
// Helper function to create test user for max devices tests
|
|
func createTestUserForMaxDevices(t *testing.T, ts *httptest.Server, adminToken string) uuid.UUID {
|
|
createUserPayload := map[string]interface{}{
|
|
"email": "maxdevices@example.com",
|
|
"username": "maxdevicesuser",
|
|
"password": "Test@Pass123!",
|
|
"first_name": "Test",
|
|
"last_name": "User",
|
|
}
|
|
|
|
jsonData, _ := json.Marshal(createUserPayload)
|
|
req, _ := http.NewRequest("POST", setup.Server.URL+"/api/auth/register", bytes.NewBuffer(jsonData))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("Authorization", "Bearer "+adminToken)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
// Check if user creation succeeded or already exists (409 Conflict)
|
|
if resp.StatusCode == http.StatusConflict {
|
|
// User already exists, try to login to get their access token
|
|
t.Logf("User maxdevices@example.com already exists, logging in to get ID")
|
|
loginPayload := map[string]interface{}{
|
|
"login": "maxdevices@example.com",
|
|
"password": "Test@Pass123!",
|
|
}
|
|
loginData, _ := json.Marshal(loginPayload)
|
|
loginReq, _ := http.NewRequest("POST", setup.Server.URL+"/api/auth/login", bytes.NewBuffer(loginData))
|
|
loginReq.Header.Set("Content-Type", "application/json")
|
|
|
|
loginResp, err := client.Do(loginReq)
|
|
require.NoError(t, err)
|
|
defer loginResp.Body.Close()
|
|
|
|
var loginResult map[string]interface{}
|
|
json.NewDecoder(loginResp.Body).Decode(&loginResult)
|
|
|
|
// Extract user_id from JWT or response
|
|
// The access_token contains the user ID in the JWT claims
|
|
if accessToken, ok := loginResult["access_token"].(string); ok {
|
|
// Simple JWT parsing to get user_id
|
|
// JWT format: header.payload.signature
|
|
parts := strings.Split(accessToken, ".")
|
|
if len(parts) >= 2 {
|
|
// Decode payload (base64url)
|
|
payload := parts[1]
|
|
// Add padding if needed
|
|
for len(payload)%4 != 0 {
|
|
payload += "="
|
|
}
|
|
// Decode base64
|
|
decodedBytes, err := base64.StdEncoding.DecodeString(payload)
|
|
if err == nil {
|
|
var claims map[string]interface{}
|
|
if err := json.Unmarshal(decodedBytes, &claims); err == nil {
|
|
t.Logf("JWT claims: %+v", claims)
|
|
if userIDStr, ok := claims["user_id"].(string); ok {
|
|
userID, _ := uuid.Parse(userIDStr)
|
|
t.Logf("Extracted userID from JWT: %s", userID)
|
|
return userID
|
|
} else {
|
|
t.Logf("user_id not found in JWT claims")
|
|
}
|
|
} else {
|
|
t.Logf("Failed to unmarshal JWT claims: %v", err)
|
|
}
|
|
} else {
|
|
t.Logf("Failed to decode base64: %v", err)
|
|
}
|
|
} else {
|
|
t.Logf("JWT doesn't have enough parts: %d", len(parts))
|
|
}
|
|
} else {
|
|
t.Logf("access_token not found in login result")
|
|
}
|
|
|
|
// If JWT parsing fails, return empty UUID
|
|
return uuid.UUID{}
|
|
}
|
|
|
|
var result map[string]interface{}
|
|
json.NewDecoder(resp.Body).Decode(&result)
|
|
|
|
// Check if user creation was successful
|
|
if result["user"] == nil {
|
|
// User creation failed for another reason
|
|
t.Logf("User creation failed, response: %+v", result)
|
|
return uuid.UUID{}
|
|
}
|
|
|
|
userIDStr := result["user"].(map[string]interface{})["id"].(string)
|
|
userID, _ := uuid.Parse(userIDStr)
|
|
|
|
return userID
|
|
}
|
|
|
|
// Helper function to get admin token
|
|
func getAdminToken(t *testing.T, ts *httptest.Server, userID uuid.UUID) string {
|
|
// First, try to login as the admin user (testuser who was created with admin role)
|
|
loginPayload := map[string]interface{}{
|
|
"login": "testuser@example.com",
|
|
"password": "Test@Pass123!",
|
|
}
|
|
|
|
jsonData, _ := json.Marshal(loginPayload)
|
|
req, _ := http.NewRequest("POST", setup.Server.URL+"/api/auth/login", bytes.NewBuffer(jsonData))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
var result map[string]interface{}
|
|
json.NewDecoder(resp.Body).Decode(&result)
|
|
|
|
// Safe type assertion with check
|
|
if accessToken, ok := result["access_token"].(string); ok {
|
|
return accessToken
|
|
}
|
|
|
|
// Handle error case - if login failed, return empty string
|
|
return ""
|
|
}
|
|
|
|
// Helper function to login user by credentials
|
|
func loginTestUserByCredentials(t *testing.T, ts *httptest.Server, email, password string) string {
|
|
loginPayload := map[string]interface{}{
|
|
"login": email,
|
|
"password": password,
|
|
}
|
|
|
|
jsonData, _ := json.Marshal(loginPayload)
|
|
req, _ := http.NewRequest("POST", setup.Server.URL+"/api/auth/login", bytes.NewBuffer(jsonData))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
require.NoError(t, err)
|
|
defer resp.Body.Close()
|
|
|
|
var result map[string]interface{}
|
|
json.NewDecoder(resp.Body).Decode(&result)
|
|
|
|
// Safe type assertion with check
|
|
if accessToken, ok := result["access_token"].(string); ok {
|
|
return accessToken
|
|
}
|
|
|
|
// Login failed - return empty string
|
|
return ""
|
|
}
|