310 lines
7.3 KiB
Go
310 lines
7.3 KiB
Go
package integration
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"testing"
|
|
|
|
"github.com/atlasos/calypso/internal/common/config"
|
|
"github.com/atlasos/calypso/internal/common/logger"
|
|
"github.com/atlasos/calypso/internal/common/password"
|
|
"github.com/atlasos/calypso/internal/common/router"
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestMain(m *testing.M) {
|
|
// Set Gin to test mode
|
|
gin.SetMode(gin.TestMode)
|
|
|
|
// Run tests
|
|
code := m.Run()
|
|
|
|
// Cleanup
|
|
if TestDB != nil {
|
|
TestDB.Close()
|
|
}
|
|
|
|
os.Exit(code)
|
|
}
|
|
|
|
func TestHealthEndpoint(t *testing.T) {
|
|
db := SetupTestDB(t)
|
|
defer CleanupTestDB(t)
|
|
|
|
cfg := TestConfig
|
|
if cfg == nil {
|
|
cfg = &config.Config{
|
|
Server: config.ServerConfig{
|
|
Port: 8080,
|
|
},
|
|
}
|
|
}
|
|
|
|
log := TestLogger
|
|
if log == nil {
|
|
log = logger.NewLogger("test")
|
|
}
|
|
r := router.NewRouter(cfg, db, log)
|
|
|
|
req := httptest.NewRequest("GET", "/api/v1/health", nil)
|
|
w := httptest.NewRecorder()
|
|
r.ServeHTTP(w, req)
|
|
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
|
|
var response map[string]interface{}
|
|
err := json.Unmarshal(w.Body.Bytes(), &response)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "calypso-api", response["service"])
|
|
}
|
|
|
|
func TestLoginEndpoint(t *testing.T) {
|
|
db := SetupTestDB(t)
|
|
defer CleanupTestDB(t)
|
|
|
|
// Create test user
|
|
passwordHash, err := password.HashPassword("testpass123", config.Argon2Params{
|
|
Memory: 64 * 1024,
|
|
Iterations: 3,
|
|
Parallelism: 4,
|
|
SaltLength: 16,
|
|
KeyLength: 32,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
userID := CreateTestUser(t, "testuser", "test@example.com", passwordHash, false)
|
|
|
|
cfg := TestConfig
|
|
if cfg == nil {
|
|
cfg = &config.Config{
|
|
Server: config.ServerConfig{
|
|
Port: 8080,
|
|
},
|
|
Auth: config.AuthConfig{
|
|
JWTSecret: "test-jwt-secret-key-minimum-32-characters-long",
|
|
TokenLifetime: 24 * 60 * 60 * 1000000000, // 24 hours in nanoseconds
|
|
},
|
|
}
|
|
}
|
|
|
|
log := TestLogger
|
|
if log == nil {
|
|
log = logger.NewLogger("test")
|
|
}
|
|
r := router.NewRouter(cfg, db, log)
|
|
|
|
// Test login
|
|
loginData := map[string]string{
|
|
"username": "testuser",
|
|
"password": "testpass123",
|
|
}
|
|
jsonData, _ := json.Marshal(loginData)
|
|
|
|
req := httptest.NewRequest("POST", "/api/v1/auth/login", bytes.NewBuffer(jsonData))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
w := httptest.NewRecorder()
|
|
r.ServeHTTP(w, req)
|
|
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
|
|
var response map[string]interface{}
|
|
err = json.Unmarshal(w.Body.Bytes(), &response)
|
|
require.NoError(t, err)
|
|
assert.NotEmpty(t, response["token"])
|
|
assert.Equal(t, userID, response["user"].(map[string]interface{})["id"])
|
|
}
|
|
|
|
func TestLoginEndpoint_WrongPassword(t *testing.T) {
|
|
db := SetupTestDB(t)
|
|
defer CleanupTestDB(t)
|
|
|
|
// Create test user
|
|
passwordHash, err := password.HashPassword("testpass123", config.Argon2Params{
|
|
Memory: 64 * 1024,
|
|
Iterations: 3,
|
|
Parallelism: 4,
|
|
SaltLength: 16,
|
|
KeyLength: 32,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
CreateTestUser(t, "testuser", "test@example.com", passwordHash, false)
|
|
|
|
cfg := TestConfig
|
|
if cfg == nil {
|
|
cfg = &config.Config{
|
|
Server: config.ServerConfig{
|
|
Port: 8080,
|
|
},
|
|
Auth: config.AuthConfig{
|
|
JWTSecret: "test-jwt-secret-key-minimum-32-characters-long",
|
|
TokenLifetime: 24 * 60 * 60 * 1000000000,
|
|
},
|
|
}
|
|
}
|
|
|
|
log := TestLogger
|
|
if log == nil {
|
|
log = logger.NewLogger("test")
|
|
}
|
|
r := router.NewRouter(cfg, db, log)
|
|
|
|
// Test login with wrong password
|
|
loginData := map[string]string{
|
|
"username": "testuser",
|
|
"password": "wrongpassword",
|
|
}
|
|
jsonData, _ := json.Marshal(loginData)
|
|
|
|
req := httptest.NewRequest("POST", "/api/v1/auth/login", bytes.NewBuffer(jsonData))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
w := httptest.NewRecorder()
|
|
r.ServeHTTP(w, req)
|
|
|
|
assert.Equal(t, http.StatusUnauthorized, w.Code)
|
|
}
|
|
|
|
func TestGetCurrentUser(t *testing.T) {
|
|
db := SetupTestDB(t)
|
|
defer CleanupTestDB(t)
|
|
|
|
// Create test user and get token
|
|
passwordHash, err := password.HashPassword("testpass123", config.Argon2Params{
|
|
Memory: 64 * 1024,
|
|
Iterations: 3,
|
|
Parallelism: 4,
|
|
SaltLength: 16,
|
|
KeyLength: 32,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
userID := CreateTestUser(t, "testuser", "test@example.com", passwordHash, false)
|
|
|
|
cfg := TestConfig
|
|
if cfg == nil {
|
|
cfg = &config.Config{
|
|
Server: config.ServerConfig{
|
|
Port: 8080,
|
|
},
|
|
Auth: config.AuthConfig{
|
|
JWTSecret: "test-jwt-secret-key-minimum-32-characters-long",
|
|
TokenLifetime: 24 * 60 * 60 * 1000000000,
|
|
},
|
|
}
|
|
}
|
|
|
|
log := TestLogger
|
|
if log == nil {
|
|
log = logger.NewLogger("test")
|
|
}
|
|
|
|
// Login to get token
|
|
loginData := map[string]string{
|
|
"username": "testuser",
|
|
"password": "testpass123",
|
|
}
|
|
jsonData, _ := json.Marshal(loginData)
|
|
|
|
r := router.NewRouter(cfg, db, log)
|
|
req := httptest.NewRequest("POST", "/api/v1/auth/login", bytes.NewBuffer(jsonData))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
w := httptest.NewRecorder()
|
|
r.ServeHTTP(w, req)
|
|
|
|
require.Equal(t, http.StatusOK, w.Code)
|
|
|
|
var loginResponse map[string]interface{}
|
|
err = json.Unmarshal(w.Body.Bytes(), &loginResponse)
|
|
require.NoError(t, err)
|
|
token := loginResponse["token"].(string)
|
|
|
|
// Test /auth/me endpoint (use same router instance)
|
|
req2 := httptest.NewRequest("GET", "/api/v1/auth/me", nil)
|
|
req2.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))
|
|
w2 := httptest.NewRecorder()
|
|
r.ServeHTTP(w2, req2)
|
|
|
|
assert.Equal(t, http.StatusOK, w2.Code)
|
|
|
|
var userResponse map[string]interface{}
|
|
err = json.Unmarshal(w2.Body.Bytes(), &userResponse)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, userID, userResponse["id"])
|
|
assert.Equal(t, "testuser", userResponse["username"])
|
|
}
|
|
|
|
func TestListAlerts(t *testing.T) {
|
|
db := SetupTestDB(t)
|
|
defer CleanupTestDB(t)
|
|
|
|
// Create test user and get token
|
|
passwordHash, err := password.HashPassword("testpass123", config.Argon2Params{
|
|
Memory: 64 * 1024,
|
|
Iterations: 3,
|
|
Parallelism: 4,
|
|
SaltLength: 16,
|
|
KeyLength: 32,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
CreateTestUser(t, "testuser", "test@example.com", passwordHash, true) // Admin user
|
|
|
|
cfg := TestConfig
|
|
if cfg == nil {
|
|
cfg = &config.Config{
|
|
Server: config.ServerConfig{
|
|
Port: 8080,
|
|
},
|
|
Auth: config.AuthConfig{
|
|
JWTSecret: "test-jwt-secret-key-minimum-32-characters-long",
|
|
TokenLifetime: 24 * 60 * 60 * 1000000000,
|
|
},
|
|
}
|
|
}
|
|
|
|
log := TestLogger
|
|
if log == nil {
|
|
log = logger.NewLogger("test")
|
|
}
|
|
r := router.NewRouter(cfg, db, log)
|
|
|
|
// Login to get token
|
|
loginData := map[string]string{
|
|
"username": "testuser",
|
|
"password": "testpass123",
|
|
}
|
|
jsonData, _ := json.Marshal(loginData)
|
|
|
|
req := httptest.NewRequest("POST", "/api/v1/auth/login", bytes.NewBuffer(jsonData))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
w := httptest.NewRecorder()
|
|
r.ServeHTTP(w, req)
|
|
|
|
require.Equal(t, http.StatusOK, w.Code)
|
|
|
|
var loginResponse map[string]interface{}
|
|
err = json.Unmarshal(w.Body.Bytes(), &loginResponse)
|
|
require.NoError(t, err)
|
|
token := loginResponse["token"].(string)
|
|
|
|
// Test /monitoring/alerts endpoint (use same router instance)
|
|
req2 := httptest.NewRequest("GET", "/api/v1/monitoring/alerts", nil)
|
|
req2.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))
|
|
w2 := httptest.NewRecorder()
|
|
r.ServeHTTP(w2, req2)
|
|
|
|
assert.Equal(t, http.StatusOK, w2.Code)
|
|
|
|
var alertsResponse map[string]interface{}
|
|
err = json.Unmarshal(w2.Body.Bytes(), &alertsResponse)
|
|
require.NoError(t, err)
|
|
assert.NotNil(t, alertsResponse["alerts"])
|
|
}
|
|
|