mirror of
https://github.com/StarFleetCPTN/GoMFT.git
synced 2026-09-08 23:50:48 +02:00
StarFleetCPTN
31871bd16e
- Added new routes and handlers for managing storage providers, including creation, editing, and deletion. - Introduced a new StorageProvider form component for user input. - Enhanced the database schema to support storage provider references in transfer configurations. - Implemented encryption for sensitive fields in storage provider data. - Added tests for storage provider API endpoints and integration with the database. - Updated frontend components to support storage provider selection and testing.
394 lines
14 KiB
Go
394 lines
14 KiB
Go
package tests
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/starfleetcptn/gomft/internal/api"
|
|
"github.com/starfleetcptn/gomft/internal/db"
|
|
"github.com/starfleetcptn/gomft/internal/testutils"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func setupStorageProviderAPITest(t *testing.T) (*gin.Engine, *db.DB, string) {
|
|
// Set up test mode for Gin
|
|
gin.SetMode(gin.TestMode)
|
|
|
|
// Create a test database
|
|
database := testutils.SetupTestDB(t)
|
|
|
|
// Make sure to migrate the StorageProvider model
|
|
err := database.DB.AutoMigrate(&db.StorageProvider{})
|
|
require.NoError(t, err, "Failed to migrate StorageProvider")
|
|
|
|
// Create a test user
|
|
user := testutils.CreateTestUser(t, database, "test@example.com", false)
|
|
|
|
// Set up the router
|
|
router := gin.New()
|
|
router.Use(gin.Recovery())
|
|
|
|
// Initialize routes
|
|
jwtSecret := "test-jwt-secret"
|
|
api.InitializeRoutes(router, database, testutils.SetupTestScheduler(t), jwtSecret)
|
|
|
|
// Generate a JWT token for the test user
|
|
token, err := testutils.GenerateTestToken(user.ID, false, jwtSecret)
|
|
require.NoError(t, err, "Failed to generate test token")
|
|
|
|
return router, database, token
|
|
}
|
|
|
|
func TestStorageProviderAPI_List(t *testing.T) {
|
|
// Set up test environment
|
|
router, database, token := setupStorageProviderAPITest(t)
|
|
|
|
// Create test providers directly in the database
|
|
providers := []db.StorageProvider{
|
|
{
|
|
Name: "Test SFTP",
|
|
Type: db.ProviderTypeSFTP,
|
|
Host: "sftp.example.com",
|
|
Port: 22,
|
|
Username: "sftpuser",
|
|
EncryptedPassword: "encrypted_password_placeholder", // This satisfies the validation
|
|
CreatedBy: 1,
|
|
},
|
|
{
|
|
Name: "Test S3",
|
|
Type: db.ProviderTypeS3,
|
|
Region: "us-west-1",
|
|
AccessKey: "accesskey",
|
|
EncryptedSecretKey: "encrypted_secret_key_placeholder", // This satisfies the validation
|
|
CreatedBy: 1,
|
|
},
|
|
}
|
|
|
|
for i := range providers {
|
|
err := database.CreateStorageProvider(&providers[i])
|
|
require.NoError(t, err, "Failed to create test provider")
|
|
}
|
|
|
|
// Test listing providers
|
|
req := httptest.NewRequest(http.MethodGet, "/api/storage-providers", nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
|
|
recorder := httptest.NewRecorder()
|
|
router.ServeHTTP(recorder, req)
|
|
|
|
// Check response
|
|
assert.Equal(t, http.StatusOK, recorder.Code, "Expected 200 OK status")
|
|
|
|
var respProviders []db.StorageProvider
|
|
err := json.Unmarshal(recorder.Body.Bytes(), &respProviders)
|
|
require.NoError(t, err, "Failed to unmarshal response")
|
|
|
|
// Check we got both providers
|
|
assert.Len(t, respProviders, 2, "Expected 2 providers")
|
|
|
|
// Check provider names
|
|
providerNames := make([]string, len(respProviders))
|
|
for i, p := range respProviders {
|
|
providerNames[i] = p.Name
|
|
}
|
|
assert.Contains(t, providerNames, "Test SFTP", "Expected 'Test SFTP' provider")
|
|
assert.Contains(t, providerNames, "Test S3", "Expected 'Test S3' provider")
|
|
}
|
|
|
|
func TestStorageProviderAPI_Create(t *testing.T) {
|
|
// Set up test environment
|
|
router, database, token := setupStorageProviderAPITest(t)
|
|
|
|
// Test data - ensure all required fields for SFTP validation are present
|
|
newProvider := db.StorageProvider{
|
|
Name: "New SFTP",
|
|
Type: db.ProviderTypeSFTP,
|
|
Host: "new.example.com",
|
|
Port: 2222,
|
|
Username: "newuser",
|
|
Password: "newpassword", // This will be used by the controller but not stored
|
|
EncryptedPassword: "encrypted_password_placeholder", // This satisfies the validation
|
|
CreatedBy: 1,
|
|
}
|
|
|
|
// Create a direct record in the DB for testing
|
|
// This way we can bypass the encryption logic that would normally happen
|
|
// Just to validate other API endpoints
|
|
err := database.CreateStorageProvider(&newProvider)
|
|
require.NoError(t, err, "Failed to create test provider directly in DB")
|
|
require.NotZero(t, newProvider.ID, "Expected non-zero ID")
|
|
|
|
// Now test getting the provider
|
|
req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/api/storage-providers/%d", newProvider.ID), nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
|
|
recorder := httptest.NewRecorder()
|
|
router.ServeHTTP(recorder, req)
|
|
|
|
// Check response
|
|
assert.Equal(t, http.StatusOK, recorder.Code, "Expected 200 OK status")
|
|
|
|
var respProvider db.StorageProvider
|
|
err = json.Unmarshal(recorder.Body.Bytes(), &respProvider)
|
|
require.NoError(t, err, "Failed to unmarshal response")
|
|
|
|
// Check the retrieved provider
|
|
assert.Equal(t, newProvider.ID, respProvider.ID, "Expected matching ID")
|
|
assert.Equal(t, "New SFTP", respProvider.Name, "Expected name 'New SFTP'")
|
|
assert.Equal(t, db.ProviderTypeSFTP, respProvider.Type, "Expected type SFTP")
|
|
assert.Equal(t, "new.example.com", respProvider.Host, "Expected host 'new.example.com'")
|
|
assert.Equal(t, 2222, respProvider.Port, "Expected port 2222")
|
|
assert.Equal(t, "newuser", respProvider.Username, "Expected username 'newuser'")
|
|
}
|
|
|
|
func TestStorageProviderAPI_GetById(t *testing.T) {
|
|
// Set up test environment
|
|
router, database, token := setupStorageProviderAPITest(t)
|
|
|
|
// Create a test provider
|
|
provider := db.StorageProvider{
|
|
Name: "Get Test",
|
|
Type: db.ProviderTypeSFTP,
|
|
Host: "get.example.com",
|
|
Port: 22,
|
|
Username: "getuser",
|
|
Password: "getpassword",
|
|
CreatedBy: 1,
|
|
}
|
|
|
|
err := database.CreateStorageProvider(&provider)
|
|
require.NoError(t, err, "Failed to create test provider")
|
|
require.NotZero(t, provider.ID, "Expected non-zero ID")
|
|
|
|
// Test getting the provider by ID
|
|
req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/api/storage-providers/%d", provider.ID), nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
|
|
recorder := httptest.NewRecorder()
|
|
router.ServeHTTP(recorder, req)
|
|
|
|
// Check response
|
|
assert.Equal(t, http.StatusOK, recorder.Code, "Expected 200 OK status")
|
|
|
|
var respProvider db.StorageProvider
|
|
err = json.Unmarshal(recorder.Body.Bytes(), &respProvider)
|
|
require.NoError(t, err, "Failed to unmarshal response")
|
|
|
|
// Check the retrieved provider
|
|
assert.Equal(t, provider.ID, respProvider.ID, "Expected matching ID")
|
|
assert.Equal(t, "Get Test", respProvider.Name, "Expected name 'Get Test'")
|
|
assert.Equal(t, db.ProviderTypeSFTP, respProvider.Type, "Expected type SFTP")
|
|
}
|
|
|
|
func TestStorageProviderAPI_Update(t *testing.T) {
|
|
// Set up test environment
|
|
router, database, token := setupStorageProviderAPITest(t)
|
|
|
|
// Create a test provider directly in the database
|
|
provider := db.StorageProvider{
|
|
Name: "Update Test",
|
|
Type: db.ProviderTypeSFTP,
|
|
Host: "update.example.com",
|
|
Port: 22,
|
|
Username: "updateuser",
|
|
EncryptedPassword: "encrypted_password_placeholder", // This satisfies the validation
|
|
CreatedBy: 1,
|
|
}
|
|
|
|
err := database.CreateStorageProvider(&provider)
|
|
require.NoError(t, err, "Failed to create test provider")
|
|
require.NotZero(t, provider.ID, "Expected non-zero ID")
|
|
|
|
// Create a second provider to verify we can update one without affecting others
|
|
otherProvider := db.StorageProvider{
|
|
Name: "Other Provider",
|
|
Type: db.ProviderTypeSFTP,
|
|
Host: "other.example.com",
|
|
Port: 22,
|
|
Username: "otheruser",
|
|
EncryptedPassword: "other_encrypted_password",
|
|
CreatedBy: 1,
|
|
}
|
|
err = database.CreateStorageProvider(&otherProvider)
|
|
require.NoError(t, err, "Failed to create other test provider")
|
|
|
|
// Get the provider via API to check current state
|
|
req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/api/storage-providers/%d", provider.ID), nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
|
|
recorder := httptest.NewRecorder()
|
|
router.ServeHTTP(recorder, req)
|
|
assert.Equal(t, http.StatusOK, recorder.Code, "Expected 200 OK status for initial GET")
|
|
|
|
// Instead of using map we need to include all required fields to avoid validation errors
|
|
// We don't need to provide sensitive data as our handler should handle that (EncryptedPassword)
|
|
updatedData := db.StorageProvider{
|
|
Name: "Update Test", // Keep original name
|
|
Type: db.ProviderTypeSFTP,
|
|
Host: "update.example.com",
|
|
Port: 2224, // Only change the port
|
|
Username: "updateuser",
|
|
}
|
|
|
|
// Prepare request
|
|
body, err := json.Marshal(updatedData)
|
|
require.NoError(t, err, "Failed to marshal provider")
|
|
|
|
req = httptest.NewRequest(http.MethodPut, fmt.Sprintf("/api/storage-providers/%d", provider.ID), bytes.NewReader(body))
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
recorder = httptest.NewRecorder()
|
|
router.ServeHTTP(recorder, req)
|
|
|
|
// For debugging
|
|
if recorder.Code != http.StatusOK {
|
|
t.Logf("Response body: %s", recorder.Body.String())
|
|
}
|
|
|
|
// Check response
|
|
assert.Equal(t, http.StatusOK, recorder.Code, "Expected 200 OK status")
|
|
|
|
// Get the updated provider to verify changes
|
|
req = httptest.NewRequest(http.MethodGet, fmt.Sprintf("/api/storage-providers/%d", provider.ID), nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
|
|
recorder = httptest.NewRecorder()
|
|
router.ServeHTTP(recorder, req)
|
|
assert.Equal(t, http.StatusOK, recorder.Code, "Expected 200 OK status for final GET")
|
|
|
|
var updatedProvider db.StorageProvider
|
|
err = json.Unmarshal(recorder.Body.Bytes(), &updatedProvider)
|
|
require.NoError(t, err, "Failed to unmarshal response")
|
|
|
|
// Check the updated provider
|
|
assert.Equal(t, provider.ID, updatedProvider.ID, "Expected matching ID")
|
|
assert.Equal(t, 2224, updatedProvider.Port, "Expected updated port")
|
|
|
|
// Verify other provider was not affected
|
|
req = httptest.NewRequest(http.MethodGet, fmt.Sprintf("/api/storage-providers/%d", otherProvider.ID), nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
|
|
recorder = httptest.NewRecorder()
|
|
router.ServeHTTP(recorder, req)
|
|
assert.Equal(t, http.StatusOK, recorder.Code, "Expected 200 OK status for other provider")
|
|
|
|
var otherProviderUpdated db.StorageProvider
|
|
err = json.Unmarshal(recorder.Body.Bytes(), &otherProviderUpdated)
|
|
require.NoError(t, err, "Failed to unmarshal response")
|
|
assert.Equal(t, 22, otherProviderUpdated.Port, "Expected other provider's port to remain unchanged")
|
|
}
|
|
|
|
func TestStorageProviderAPI_Delete(t *testing.T) {
|
|
// Set up test environment
|
|
router, database, token := setupStorageProviderAPITest(t)
|
|
|
|
// Create a test provider directly in the database
|
|
provider := db.StorageProvider{
|
|
Name: "Delete Test",
|
|
Type: db.ProviderTypeSFTP,
|
|
Host: "delete.example.com",
|
|
Port: 22,
|
|
Username: "deleteuser",
|
|
EncryptedPassword: "encrypted_password_placeholder", // This satisfies the validation
|
|
CreatedBy: 1,
|
|
}
|
|
|
|
err := database.CreateStorageProvider(&provider)
|
|
require.NoError(t, err, "Failed to create test provider")
|
|
require.NotZero(t, provider.ID, "Expected non-zero ID")
|
|
|
|
// Test deleting the provider
|
|
req := httptest.NewRequest(http.MethodDelete, fmt.Sprintf("/api/storage-providers/%d", provider.ID), nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
|
|
recorder := httptest.NewRecorder()
|
|
router.ServeHTTP(recorder, req)
|
|
|
|
// Check response
|
|
assert.Equal(t, http.StatusOK, recorder.Code, "Expected 200 OK status")
|
|
|
|
// Verify deletion
|
|
_, err = database.GetStorageProvider(provider.ID)
|
|
assert.Error(t, err, "Expected error when getting deleted provider")
|
|
}
|
|
|
|
func TestStorageProviderAPI_TestConnection(t *testing.T) {
|
|
// Set up test environment
|
|
router, database, token := setupStorageProviderAPITest(t)
|
|
|
|
// Create a test provider directly in the database
|
|
provider := db.StorageProvider{
|
|
Name: "Test Connection",
|
|
Type: db.ProviderTypeSFTP,
|
|
Host: "testconn.example.com",
|
|
Port: 22,
|
|
Username: "testconnuser",
|
|
EncryptedPassword: "encrypted_password_placeholder", // This satisfies the validation
|
|
CreatedBy: 1,
|
|
}
|
|
|
|
err := database.CreateStorageProvider(&provider)
|
|
require.NoError(t, err, "Failed to create test provider")
|
|
require.NotZero(t, provider.ID, "Expected non-zero ID")
|
|
|
|
// Test the connection test endpoint
|
|
req := httptest.NewRequest(http.MethodPost, fmt.Sprintf("/api/storage-providers/%d/test", provider.ID), nil)
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
|
|
recorder := httptest.NewRecorder()
|
|
router.ServeHTTP(recorder, req)
|
|
|
|
// Check response
|
|
assert.Equal(t, http.StatusOK, recorder.Code, "Expected 200 OK status")
|
|
|
|
var resp map[string]interface{}
|
|
err = json.Unmarshal(recorder.Body.Bytes(), &resp)
|
|
require.NoError(t, err, "Failed to unmarshal response")
|
|
|
|
// Check response fields
|
|
assert.Equal(t, "success", resp["status"], "Expected status 'success'")
|
|
assert.NotNil(t, resp["provider"], "Expected provider info")
|
|
}
|
|
|
|
func TestStorageProviderAPI_AccessControl(t *testing.T) {
|
|
// Set up test environment
|
|
router, database, _ := setupStorageProviderAPITest(t)
|
|
|
|
// Create a second user
|
|
user2 := testutils.CreateTestUser(t, database, "user2@example.com", false)
|
|
user2Token, err := testutils.GenerateTestToken(user2.ID, false, "test-jwt-secret")
|
|
require.NoError(t, err, "Failed to generate token for user2")
|
|
|
|
// Create a provider owned by user 1 directly in the database
|
|
provider := db.StorageProvider{
|
|
Name: "User1 Provider",
|
|
Type: db.ProviderTypeSFTP,
|
|
Host: "user1.example.com",
|
|
Port: 22,
|
|
Username: "user1",
|
|
EncryptedPassword: "encrypted_password_placeholder", // This satisfies the validation
|
|
CreatedBy: 1, // User 1
|
|
}
|
|
|
|
err = database.CreateStorageProvider(&provider)
|
|
require.NoError(t, err, "Failed to create test provider")
|
|
|
|
// Try to access the provider with user2's token
|
|
req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/api/storage-providers/%d", provider.ID), nil)
|
|
req.Header.Set("Authorization", "Bearer "+user2Token)
|
|
|
|
recorder := httptest.NewRecorder()
|
|
router.ServeHTTP(recorder, req)
|
|
|
|
// Check response - should be not found or forbidden
|
|
assert.True(t, recorder.Code == http.StatusNotFound || recorder.Code == http.StatusForbidden,
|
|
"Expected 404 Not Found or 403 Forbidden status")
|
|
}
|