first commit
This commit is contained in:
Beyhan Oğur
803
core/internal/llmtests/containers.go
Normal file
803
core/internal/llmtests/containers.go
Normal file
@@ -0,0 +1,803 @@
|
||||
// Package llmtests provides container API test utilities for the Bifrost system.
|
||||
package llmtests
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
bifrost "github.com/maximhq/bifrost/core"
|
||||
"github.com/maximhq/bifrost/core/schemas"
|
||||
)
|
||||
|
||||
// RunContainerCreateTest tests the container create functionality
|
||||
func RunContainerCreateTest(t *testing.T, client *bifrost.Bifrost, ctx context.Context, testConfig ComprehensiveTestConfig) {
|
||||
if !testConfig.Scenarios.ContainerCreate {
|
||||
t.Logf("[SKIPPED] Container Create: Not supported by provider %s", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
|
||||
t.Run("ContainerCreate", func(t *testing.T) {
|
||||
t.Logf("[RUNNING] Container Create test for provider: %s", testConfig.Provider)
|
||||
|
||||
request := &schemas.BifrostContainerCreateRequest{
|
||||
Provider: testConfig.Provider,
|
||||
Name: "bifrost-test-container",
|
||||
}
|
||||
|
||||
bfCtx := schemas.NewBifrostContext(ctx, schemas.NoDeadline)
|
||||
response, err := client.ContainerCreateRequest(bfCtx, request)
|
||||
|
||||
if err != nil {
|
||||
// Check if this is an unsupported operation error
|
||||
if err.Error != nil && (err.Error.Code != nil && *err.Error.Code == "unsupported_operation") {
|
||||
t.Logf("[EXPECTED] Provider %s returned unsupported operation error", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
t.Fatalf("❌ ContainerCreate failed: %v", GetErrorMessage(err))
|
||||
}
|
||||
|
||||
if response == nil {
|
||||
t.Fatal("❌ ContainerCreate returned nil response")
|
||||
}
|
||||
|
||||
if response.ID == "" {
|
||||
t.Fatal("❌ ContainerCreate returned empty container ID")
|
||||
}
|
||||
|
||||
t.Logf("✅ Container Create test passed for provider: %s, container ID: %s", testConfig.Provider, response.ID)
|
||||
|
||||
// Clean up: delete the created container
|
||||
deleteRequest := &schemas.BifrostContainerDeleteRequest{
|
||||
Provider: testConfig.Provider,
|
||||
ContainerID: response.ID,
|
||||
}
|
||||
_, deleteErr := client.ContainerDeleteRequest(bfCtx, deleteRequest)
|
||||
if deleteErr != nil {
|
||||
t.Logf("[WARNING] Failed to clean up container %s: %v", response.ID, GetErrorMessage(deleteErr))
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// RunContainerListTest tests the container list functionality
|
||||
func RunContainerListTest(t *testing.T, client *bifrost.Bifrost, ctx context.Context, testConfig ComprehensiveTestConfig) {
|
||||
if !testConfig.Scenarios.ContainerList {
|
||||
t.Logf("[SKIPPED] Container List: Not supported by provider %s", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
|
||||
t.Run("ContainerList", func(t *testing.T) {
|
||||
t.Logf("[RUNNING] Container List test for provider: %s", testConfig.Provider)
|
||||
|
||||
request := &schemas.BifrostContainerListRequest{
|
||||
Provider: testConfig.Provider,
|
||||
Limit: 10,
|
||||
}
|
||||
|
||||
bfCtx := schemas.NewBifrostContext(ctx, schemas.NoDeadline)
|
||||
response, err := client.ContainerListRequest(bfCtx, request)
|
||||
|
||||
if err != nil {
|
||||
// Check if this is an unsupported operation error
|
||||
if err.Error != nil && (err.Error.Code != nil && *err.Error.Code == "unsupported_operation") {
|
||||
t.Logf("[EXPECTED] Provider %s returned unsupported operation error", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
t.Fatalf("❌ ContainerList failed: %v", GetErrorMessage(err))
|
||||
}
|
||||
|
||||
if response == nil {
|
||||
t.Fatal("❌ ContainerList returned nil response")
|
||||
}
|
||||
|
||||
t.Logf("✅ Container List test passed for provider: %s, found %d containers", testConfig.Provider, len(response.Data))
|
||||
})
|
||||
}
|
||||
|
||||
// RunContainerRetrieveTest tests the container retrieve functionality
|
||||
func RunContainerRetrieveTest(t *testing.T, client *bifrost.Bifrost, ctx context.Context, testConfig ComprehensiveTestConfig) {
|
||||
if !testConfig.Scenarios.ContainerRetrieve {
|
||||
t.Logf("[SKIPPED] Container Retrieve: Not supported by provider %s", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
|
||||
t.Run("ContainerRetrieve", func(t *testing.T) {
|
||||
t.Logf("[RUNNING] Container Retrieve test for provider: %s", testConfig.Provider)
|
||||
|
||||
// First, create a container to retrieve
|
||||
createRequest := &schemas.BifrostContainerCreateRequest{
|
||||
Provider: testConfig.Provider,
|
||||
Name: "bifrost-test-container-retrieve",
|
||||
}
|
||||
|
||||
bfCtx := schemas.NewBifrostContext(ctx, schemas.NoDeadline)
|
||||
createResponse, createErr := client.ContainerCreateRequest(bfCtx, createRequest)
|
||||
|
||||
if createErr != nil {
|
||||
if createErr.Error != nil && (createErr.Error.Code != nil && *createErr.Error.Code == "unsupported_operation") {
|
||||
t.Logf("[EXPECTED] Provider %s returned unsupported operation error", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
t.Fatalf("❌ ContainerCreate (setup) failed: %v", GetErrorMessage(createErr))
|
||||
}
|
||||
|
||||
if createResponse == nil || createResponse.ID == "" {
|
||||
t.Fatal("❌ ContainerCreate (setup) returned nil or empty response")
|
||||
}
|
||||
|
||||
containerID := createResponse.ID
|
||||
defer func() {
|
||||
// Clean up
|
||||
deleteRequest := &schemas.BifrostContainerDeleteRequest{
|
||||
Provider: testConfig.Provider,
|
||||
ContainerID: containerID,
|
||||
}
|
||||
_, _ = client.ContainerDeleteRequest(bfCtx, deleteRequest)
|
||||
}()
|
||||
|
||||
// Now retrieve the container
|
||||
retrieveRequest := &schemas.BifrostContainerRetrieveRequest{
|
||||
Provider: testConfig.Provider,
|
||||
ContainerID: containerID,
|
||||
}
|
||||
|
||||
response, err := client.ContainerRetrieveRequest(bfCtx, retrieveRequest)
|
||||
|
||||
if err != nil {
|
||||
t.Fatalf("❌ ContainerRetrieve failed: %v", GetErrorMessage(err))
|
||||
}
|
||||
|
||||
if response == nil {
|
||||
t.Fatal("❌ ContainerRetrieve returned nil response")
|
||||
}
|
||||
|
||||
if response.ID != containerID {
|
||||
t.Fatalf("❌ ContainerRetrieve returned wrong container ID: expected %s, got %s", containerID, response.ID)
|
||||
}
|
||||
|
||||
t.Logf("✅ Container Retrieve test passed for provider: %s, container ID: %s", testConfig.Provider, response.ID)
|
||||
})
|
||||
}
|
||||
|
||||
// RunContainerDeleteTest tests the container delete functionality
|
||||
func RunContainerDeleteTest(t *testing.T, client *bifrost.Bifrost, ctx context.Context, testConfig ComprehensiveTestConfig) {
|
||||
if !testConfig.Scenarios.ContainerDelete {
|
||||
t.Logf("[SKIPPED] Container Delete: Not supported by provider %s", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
|
||||
t.Run("ContainerDelete", func(t *testing.T) {
|
||||
t.Logf("[RUNNING] Container Delete test for provider: %s", testConfig.Provider)
|
||||
|
||||
// First, create a container to delete
|
||||
createRequest := &schemas.BifrostContainerCreateRequest{
|
||||
Provider: testConfig.Provider,
|
||||
Name: "bifrost-test-container-delete",
|
||||
}
|
||||
|
||||
bfCtx := schemas.NewBifrostContext(ctx, schemas.NoDeadline)
|
||||
createResponse, createErr := client.ContainerCreateRequest(bfCtx, createRequest)
|
||||
|
||||
if createErr != nil {
|
||||
if createErr.Error != nil && (createErr.Error.Code != nil && *createErr.Error.Code == "unsupported_operation") {
|
||||
t.Logf("[EXPECTED] Provider %s returned unsupported operation error", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
t.Fatalf("❌ ContainerCreate (setup) failed: %v", GetErrorMessage(createErr))
|
||||
}
|
||||
|
||||
if createResponse == nil || createResponse.ID == "" {
|
||||
t.Fatal("❌ ContainerCreate (setup) returned nil or empty response")
|
||||
}
|
||||
|
||||
containerID := createResponse.ID
|
||||
|
||||
// Now delete the container
|
||||
deleteRequest := &schemas.BifrostContainerDeleteRequest{
|
||||
Provider: testConfig.Provider,
|
||||
ContainerID: containerID,
|
||||
}
|
||||
|
||||
response, err := client.ContainerDeleteRequest(bfCtx, deleteRequest)
|
||||
|
||||
if err != nil {
|
||||
t.Fatalf("❌ ContainerDelete failed: %v", GetErrorMessage(err))
|
||||
}
|
||||
|
||||
if response == nil {
|
||||
t.Fatal("❌ ContainerDelete returned nil response")
|
||||
}
|
||||
|
||||
if !response.Deleted {
|
||||
t.Fatal("❌ ContainerDelete returned deleted=false")
|
||||
}
|
||||
|
||||
t.Logf("✅ Container Delete test passed for provider: %s, container ID: %s", testConfig.Provider, containerID)
|
||||
})
|
||||
}
|
||||
|
||||
// RunContainerUnsupportedTest tests that providers correctly return unsupported operation errors
|
||||
func RunContainerUnsupportedTest(t *testing.T, client *bifrost.Bifrost, ctx context.Context, testConfig ComprehensiveTestConfig) {
|
||||
// Only run this test if none of the container operations are supported
|
||||
if testConfig.Scenarios.ContainerCreate || testConfig.Scenarios.ContainerList ||
|
||||
testConfig.Scenarios.ContainerRetrieve || testConfig.Scenarios.ContainerDelete {
|
||||
t.Logf("[SKIPPED] Container Unsupported: Provider %s supports container operations", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
|
||||
t.Run("ContainerUnsupported", func(t *testing.T) {
|
||||
t.Logf("[RUNNING] Container Unsupported test for provider: %s", testConfig.Provider)
|
||||
|
||||
bfCtx := schemas.NewBifrostContext(ctx, schemas.NoDeadline)
|
||||
|
||||
// Test ContainerCreate returns unsupported
|
||||
createRequest := &schemas.BifrostContainerCreateRequest{
|
||||
Provider: testConfig.Provider,
|
||||
Name: "test-container",
|
||||
}
|
||||
_, createErr := client.ContainerCreateRequest(bfCtx, createRequest)
|
||||
|
||||
if createErr == nil {
|
||||
t.Fatal("❌ Expected unsupported operation error for ContainerCreate, got nil")
|
||||
}
|
||||
|
||||
if createErr.Error == nil || createErr.Error.Code == nil || *createErr.Error.Code != "unsupported_operation" {
|
||||
t.Fatalf("❌ Expected unsupported_operation error code, got: %v", createErr)
|
||||
}
|
||||
|
||||
t.Logf("✅ Container Unsupported test passed for provider: %s", testConfig.Provider)
|
||||
})
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// CONTAINER FILES API TESTS
|
||||
// =============================================================================
|
||||
|
||||
// RunContainerFileCreateTest tests the container file create functionality
|
||||
func RunContainerFileCreateTest(t *testing.T, client *bifrost.Bifrost, ctx context.Context, testConfig ComprehensiveTestConfig) {
|
||||
if !testConfig.Scenarios.ContainerFileCreate {
|
||||
t.Logf("[SKIPPED] Container File Create: Not supported by provider %s", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
|
||||
t.Run("ContainerFileCreate", func(t *testing.T) {
|
||||
t.Logf("[RUNNING] Container File Create test for provider: %s", testConfig.Provider)
|
||||
|
||||
bfCtx := schemas.NewBifrostContext(ctx, schemas.NoDeadline)
|
||||
|
||||
// First, create a container to hold the file
|
||||
containerRequest := &schemas.BifrostContainerCreateRequest{
|
||||
Provider: testConfig.Provider,
|
||||
Name: "bifrost-test-container-file-create",
|
||||
}
|
||||
|
||||
containerResponse, containerErr := client.ContainerCreateRequest(bfCtx, containerRequest)
|
||||
if containerErr != nil {
|
||||
if containerErr.Error != nil && (containerErr.Error.Code != nil && *containerErr.Error.Code == "unsupported_operation") {
|
||||
t.Logf("[EXPECTED] Provider %s returned unsupported operation error for container creation", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
t.Fatalf("❌ ContainerCreate (setup) failed: %v", GetErrorMessage(containerErr))
|
||||
}
|
||||
|
||||
if containerResponse == nil || containerResponse.ID == "" {
|
||||
t.Fatal("❌ ContainerCreate (setup) returned nil or empty response")
|
||||
}
|
||||
|
||||
containerID := containerResponse.ID
|
||||
defer func() {
|
||||
// Clean up container
|
||||
deleteRequest := &schemas.BifrostContainerDeleteRequest{
|
||||
Provider: testConfig.Provider,
|
||||
ContainerID: containerID,
|
||||
}
|
||||
_, _ = client.ContainerDeleteRequest(bfCtx, deleteRequest)
|
||||
}()
|
||||
|
||||
// Create a file in the container
|
||||
testContent := []byte("Hello, Bifrost! This is a test file for container file operations.")
|
||||
filePath := "/test-file.txt"
|
||||
|
||||
fileCreateRequest := &schemas.BifrostContainerFileCreateRequest{
|
||||
Provider: testConfig.Provider,
|
||||
ContainerID: containerID,
|
||||
File: testContent,
|
||||
Path: &filePath,
|
||||
}
|
||||
|
||||
response, err := client.ContainerFileCreateRequest(bfCtx, fileCreateRequest)
|
||||
|
||||
if err != nil {
|
||||
if err.Error != nil && (err.Error.Code != nil && *err.Error.Code == "unsupported_operation") {
|
||||
t.Logf("[EXPECTED] Provider %s returned unsupported operation error", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
t.Fatalf("❌ ContainerFileCreate failed: %v", GetErrorMessage(err))
|
||||
}
|
||||
|
||||
if response == nil {
|
||||
t.Fatal("❌ ContainerFileCreate returned nil response")
|
||||
}
|
||||
|
||||
if response.ID == "" {
|
||||
t.Fatal("❌ ContainerFileCreate returned empty file ID")
|
||||
}
|
||||
|
||||
if response.ContainerID != containerID {
|
||||
t.Fatalf("❌ ContainerFileCreate returned wrong container ID: expected %s, got %s", containerID, response.ContainerID)
|
||||
}
|
||||
|
||||
t.Logf("✅ Container File Create test passed for provider: %s, file ID: %s", testConfig.Provider, response.ID)
|
||||
|
||||
// Clean up file
|
||||
fileDeleteRequest := &schemas.BifrostContainerFileDeleteRequest{
|
||||
Provider: testConfig.Provider,
|
||||
ContainerID: containerID,
|
||||
FileID: response.ID,
|
||||
}
|
||||
_, _ = client.ContainerFileDeleteRequest(bfCtx, fileDeleteRequest)
|
||||
})
|
||||
}
|
||||
|
||||
// RunContainerFileListTest tests the container file list functionality
|
||||
func RunContainerFileListTest(t *testing.T, client *bifrost.Bifrost, ctx context.Context, testConfig ComprehensiveTestConfig) {
|
||||
if !testConfig.Scenarios.ContainerFileList {
|
||||
t.Logf("[SKIPPED] Container File List: Not supported by provider %s", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
|
||||
t.Run("ContainerFileList", func(t *testing.T) {
|
||||
t.Logf("[RUNNING] Container File List test for provider: %s", testConfig.Provider)
|
||||
|
||||
bfCtx := schemas.NewBifrostContext(ctx, schemas.NoDeadline)
|
||||
|
||||
// First, create a container
|
||||
containerRequest := &schemas.BifrostContainerCreateRequest{
|
||||
Provider: testConfig.Provider,
|
||||
Name: "bifrost-test-container-file-list",
|
||||
}
|
||||
|
||||
containerResponse, containerErr := client.ContainerCreateRequest(bfCtx, containerRequest)
|
||||
if containerErr != nil {
|
||||
if containerErr.Error != nil && (containerErr.Error.Code != nil && *containerErr.Error.Code == "unsupported_operation") {
|
||||
t.Logf("[EXPECTED] Provider %s returned unsupported operation error for container creation", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
t.Fatalf("❌ ContainerCreate (setup) failed: %v", GetErrorMessage(containerErr))
|
||||
}
|
||||
|
||||
if containerResponse == nil || containerResponse.ID == "" {
|
||||
t.Fatal("❌ ContainerCreate (setup) returned nil or empty response")
|
||||
}
|
||||
|
||||
containerID := containerResponse.ID
|
||||
defer func() {
|
||||
// Clean up container
|
||||
deleteRequest := &schemas.BifrostContainerDeleteRequest{
|
||||
Provider: testConfig.Provider,
|
||||
ContainerID: containerID,
|
||||
}
|
||||
_, _ = client.ContainerDeleteRequest(bfCtx, deleteRequest)
|
||||
}()
|
||||
|
||||
// Create a file in the container first
|
||||
testContent := []byte("Test content for file list")
|
||||
filePath := "/test-file-list.txt"
|
||||
|
||||
fileCreateRequest := &schemas.BifrostContainerFileCreateRequest{
|
||||
Provider: testConfig.Provider,
|
||||
ContainerID: containerID,
|
||||
File: testContent,
|
||||
Path: &filePath,
|
||||
}
|
||||
|
||||
fileCreateResponse, fileCreateErr := client.ContainerFileCreateRequest(bfCtx, fileCreateRequest)
|
||||
if fileCreateErr != nil {
|
||||
if fileCreateErr.Error != nil && (fileCreateErr.Error.Code != nil && *fileCreateErr.Error.Code == "unsupported_operation") {
|
||||
t.Logf("[EXPECTED] Provider %s returned unsupported operation error for file creation", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
t.Fatalf("❌ ContainerFileCreate (setup) failed: %v", GetErrorMessage(fileCreateErr))
|
||||
}
|
||||
|
||||
if fileCreateResponse == nil {
|
||||
t.Fatal("❌ ContainerFileCreate (setup) returned nil response with no error")
|
||||
}
|
||||
|
||||
fileID := fileCreateResponse.ID
|
||||
defer func() {
|
||||
// Clean up file
|
||||
fileDeleteRequest := &schemas.BifrostContainerFileDeleteRequest{
|
||||
Provider: testConfig.Provider,
|
||||
ContainerID: containerID,
|
||||
FileID: fileID,
|
||||
}
|
||||
_, _ = client.ContainerFileDeleteRequest(bfCtx, fileDeleteRequest)
|
||||
}()
|
||||
|
||||
// Now list files in the container
|
||||
listRequest := &schemas.BifrostContainerFileListRequest{
|
||||
Provider: testConfig.Provider,
|
||||
ContainerID: containerID,
|
||||
Limit: 10,
|
||||
}
|
||||
|
||||
response, err := client.ContainerFileListRequest(bfCtx, listRequest)
|
||||
|
||||
if err != nil {
|
||||
if err.Error != nil && (err.Error.Code != nil && *err.Error.Code == "unsupported_operation") {
|
||||
t.Logf("[EXPECTED] Provider %s returned unsupported operation error", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
t.Fatalf("❌ ContainerFileList failed: %v", GetErrorMessage(err))
|
||||
}
|
||||
|
||||
if response == nil {
|
||||
t.Fatal("❌ ContainerFileList returned nil response")
|
||||
}
|
||||
|
||||
if len(response.Data) == 0 {
|
||||
t.Fatal("❌ ContainerFileList returned empty list, expected at least one file")
|
||||
}
|
||||
|
||||
t.Logf("✅ Container File List test passed for provider: %s, found %d files", testConfig.Provider, len(response.Data))
|
||||
})
|
||||
}
|
||||
|
||||
// RunContainerFileRetrieveTest tests the container file retrieve functionality
|
||||
func RunContainerFileRetrieveTest(t *testing.T, client *bifrost.Bifrost, ctx context.Context, testConfig ComprehensiveTestConfig) {
|
||||
if !testConfig.Scenarios.ContainerFileRetrieve {
|
||||
t.Logf("[SKIPPED] Container File Retrieve: Not supported by provider %s", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
|
||||
t.Run("ContainerFileRetrieve", func(t *testing.T) {
|
||||
t.Logf("[RUNNING] Container File Retrieve test for provider: %s", testConfig.Provider)
|
||||
|
||||
bfCtx := schemas.NewBifrostContext(ctx, schemas.NoDeadline)
|
||||
|
||||
// First, create a container
|
||||
containerRequest := &schemas.BifrostContainerCreateRequest{
|
||||
Provider: testConfig.Provider,
|
||||
Name: "bifrost-test-container-file-retrieve",
|
||||
}
|
||||
|
||||
containerResponse, containerErr := client.ContainerCreateRequest(bfCtx, containerRequest)
|
||||
if containerErr != nil {
|
||||
if containerErr.Error != nil && (containerErr.Error.Code != nil && *containerErr.Error.Code == "unsupported_operation") {
|
||||
t.Logf("[EXPECTED] Provider %s returned unsupported operation error for container creation", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
t.Fatalf("❌ ContainerCreate (setup) failed: %v", GetErrorMessage(containerErr))
|
||||
}
|
||||
|
||||
if containerResponse == nil || containerResponse.ID == "" {
|
||||
t.Fatal("❌ ContainerCreate (setup) returned nil or empty response")
|
||||
}
|
||||
|
||||
containerID := containerResponse.ID
|
||||
defer func() {
|
||||
// Clean up container
|
||||
deleteRequest := &schemas.BifrostContainerDeleteRequest{
|
||||
Provider: testConfig.Provider,
|
||||
ContainerID: containerID,
|
||||
}
|
||||
_, _ = client.ContainerDeleteRequest(bfCtx, deleteRequest)
|
||||
}()
|
||||
|
||||
// Create a file in the container
|
||||
testContent := []byte("Test content for file retrieve")
|
||||
filePath := "/test-file-retrieve.txt"
|
||||
|
||||
fileCreateRequest := &schemas.BifrostContainerFileCreateRequest{
|
||||
Provider: testConfig.Provider,
|
||||
ContainerID: containerID,
|
||||
File: testContent,
|
||||
Path: &filePath,
|
||||
}
|
||||
|
||||
fileCreateResponse, fileCreateErr := client.ContainerFileCreateRequest(bfCtx, fileCreateRequest)
|
||||
if fileCreateErr != nil {
|
||||
if fileCreateErr.Error != nil && (fileCreateErr.Error.Code != nil && *fileCreateErr.Error.Code == "unsupported_operation") {
|
||||
t.Logf("[EXPECTED] Provider %s returned unsupported operation error for file creation", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
t.Fatalf("❌ ContainerFileCreate (setup) failed: %v", GetErrorMessage(fileCreateErr))
|
||||
}
|
||||
|
||||
if fileCreateResponse == nil {
|
||||
t.Fatal("❌ ContainerFileCreate (setup) returned nil response with no error")
|
||||
}
|
||||
|
||||
fileID := fileCreateResponse.ID
|
||||
defer func() {
|
||||
// Clean up file
|
||||
fileDeleteRequest := &schemas.BifrostContainerFileDeleteRequest{
|
||||
Provider: testConfig.Provider,
|
||||
ContainerID: containerID,
|
||||
FileID: fileID,
|
||||
}
|
||||
_, _ = client.ContainerFileDeleteRequest(bfCtx, fileDeleteRequest)
|
||||
}()
|
||||
|
||||
// Now retrieve the file
|
||||
retrieveRequest := &schemas.BifrostContainerFileRetrieveRequest{
|
||||
Provider: testConfig.Provider,
|
||||
ContainerID: containerID,
|
||||
FileID: fileID,
|
||||
}
|
||||
|
||||
response, err := client.ContainerFileRetrieveRequest(bfCtx, retrieveRequest)
|
||||
|
||||
if err != nil {
|
||||
if err.Error != nil && (err.Error.Code != nil && *err.Error.Code == "unsupported_operation") {
|
||||
t.Logf("[EXPECTED] Provider %s returned unsupported operation error", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
t.Fatalf("❌ ContainerFileRetrieve failed: %v", GetErrorMessage(err))
|
||||
}
|
||||
|
||||
if response == nil {
|
||||
t.Fatal("❌ ContainerFileRetrieve returned nil response")
|
||||
}
|
||||
|
||||
if response.ID != fileID {
|
||||
t.Fatalf("❌ ContainerFileRetrieve returned wrong file ID: expected %s, got %s", fileID, response.ID)
|
||||
}
|
||||
|
||||
if response.ContainerID != containerID {
|
||||
t.Fatalf("❌ ContainerFileRetrieve returned wrong container ID: expected %s, got %s", containerID, response.ContainerID)
|
||||
}
|
||||
|
||||
t.Logf("✅ Container File Retrieve test passed for provider: %s, file ID: %s", testConfig.Provider, response.ID)
|
||||
})
|
||||
}
|
||||
|
||||
// RunContainerFileContentTest tests the container file content functionality
|
||||
func RunContainerFileContentTest(t *testing.T, client *bifrost.Bifrost, ctx context.Context, testConfig ComprehensiveTestConfig) {
|
||||
if !testConfig.Scenarios.ContainerFileContent {
|
||||
t.Logf("[SKIPPED] Container File Content: Not supported by provider %s", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
|
||||
t.Run("ContainerFileContent", func(t *testing.T) {
|
||||
t.Logf("[RUNNING] Container File Content test for provider: %s", testConfig.Provider)
|
||||
|
||||
bfCtx := schemas.NewBifrostContext(ctx, schemas.NoDeadline)
|
||||
|
||||
// First, create a container
|
||||
containerRequest := &schemas.BifrostContainerCreateRequest{
|
||||
Provider: testConfig.Provider,
|
||||
Name: "bifrost-test-container-file-content",
|
||||
}
|
||||
|
||||
containerResponse, containerErr := client.ContainerCreateRequest(bfCtx, containerRequest)
|
||||
if containerErr != nil {
|
||||
if containerErr.Error != nil && (containerErr.Error.Code != nil && *containerErr.Error.Code == "unsupported_operation") {
|
||||
t.Logf("[EXPECTED] Provider %s returned unsupported operation error for container creation", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
t.Fatalf("❌ ContainerCreate (setup) failed: %v", GetErrorMessage(containerErr))
|
||||
}
|
||||
|
||||
if containerResponse == nil || containerResponse.ID == "" {
|
||||
t.Fatal("❌ ContainerCreate (setup) returned nil or empty response")
|
||||
}
|
||||
|
||||
containerID := containerResponse.ID
|
||||
defer func() {
|
||||
// Clean up container
|
||||
deleteRequest := &schemas.BifrostContainerDeleteRequest{
|
||||
Provider: testConfig.Provider,
|
||||
ContainerID: containerID,
|
||||
}
|
||||
_, _ = client.ContainerDeleteRequest(bfCtx, deleteRequest)
|
||||
}()
|
||||
|
||||
// Create a file in the container with known content
|
||||
testContent := []byte("Hello, Bifrost! This is test content for file content retrieval.")
|
||||
filePath := "/test-file-content.txt"
|
||||
|
||||
fileCreateRequest := &schemas.BifrostContainerFileCreateRequest{
|
||||
Provider: testConfig.Provider,
|
||||
ContainerID: containerID,
|
||||
File: testContent,
|
||||
Path: &filePath,
|
||||
}
|
||||
|
||||
fileCreateResponse, fileCreateErr := client.ContainerFileCreateRequest(bfCtx, fileCreateRequest)
|
||||
if fileCreateErr != nil {
|
||||
if fileCreateErr.Error != nil && (fileCreateErr.Error.Code != nil && *fileCreateErr.Error.Code == "unsupported_operation") {
|
||||
t.Logf("[EXPECTED] Provider %s returned unsupported operation error for file creation", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
t.Fatalf("❌ ContainerFileCreate (setup) failed: %v", GetErrorMessage(fileCreateErr))
|
||||
}
|
||||
|
||||
if fileCreateResponse == nil {
|
||||
t.Fatal("❌ ContainerFileCreate (setup) returned nil response with no error")
|
||||
}
|
||||
|
||||
fileID := fileCreateResponse.ID
|
||||
defer func() {
|
||||
// Clean up file
|
||||
fileDeleteRequest := &schemas.BifrostContainerFileDeleteRequest{
|
||||
Provider: testConfig.Provider,
|
||||
ContainerID: containerID,
|
||||
FileID: fileID,
|
||||
}
|
||||
_, _ = client.ContainerFileDeleteRequest(bfCtx, fileDeleteRequest)
|
||||
}()
|
||||
|
||||
// Now retrieve the file content
|
||||
contentRequest := &schemas.BifrostContainerFileContentRequest{
|
||||
Provider: testConfig.Provider,
|
||||
ContainerID: containerID,
|
||||
FileID: fileID,
|
||||
}
|
||||
|
||||
response, err := client.ContainerFileContentRequest(bfCtx, contentRequest)
|
||||
|
||||
if err != nil {
|
||||
if err.Error != nil && (err.Error.Code != nil && *err.Error.Code == "unsupported_operation") {
|
||||
t.Logf("[EXPECTED] Provider %s returned unsupported operation error", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
t.Fatalf("❌ ContainerFileContent failed: %v", GetErrorMessage(err))
|
||||
}
|
||||
|
||||
if response == nil {
|
||||
t.Fatal("❌ ContainerFileContent returned nil response")
|
||||
}
|
||||
|
||||
if len(response.Content) == 0 {
|
||||
t.Fatal("❌ ContainerFileContent returned empty content")
|
||||
}
|
||||
|
||||
// Verify content matches what we uploaded
|
||||
if string(response.Content) != string(testContent) {
|
||||
t.Fatalf("❌ ContainerFileContent returned wrong content: expected %q, got %q", string(testContent), string(response.Content))
|
||||
}
|
||||
|
||||
t.Logf("✅ Container File Content test passed for provider: %s, content length: %d bytes", testConfig.Provider, len(response.Content))
|
||||
})
|
||||
}
|
||||
|
||||
// RunContainerFileDeleteTest tests the container file delete functionality
|
||||
func RunContainerFileDeleteTest(t *testing.T, client *bifrost.Bifrost, ctx context.Context, testConfig ComprehensiveTestConfig) {
|
||||
if !testConfig.Scenarios.ContainerFileDelete {
|
||||
t.Logf("[SKIPPED] Container File Delete: Not supported by provider %s", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
|
||||
t.Run("ContainerFileDelete", func(t *testing.T) {
|
||||
t.Logf("[RUNNING] Container File Delete test for provider: %s", testConfig.Provider)
|
||||
|
||||
bfCtx := schemas.NewBifrostContext(ctx, schemas.NoDeadline)
|
||||
|
||||
// First, create a container
|
||||
containerRequest := &schemas.BifrostContainerCreateRequest{
|
||||
Provider: testConfig.Provider,
|
||||
Name: "bifrost-test-container-file-delete",
|
||||
}
|
||||
|
||||
containerResponse, containerErr := client.ContainerCreateRequest(bfCtx, containerRequest)
|
||||
if containerErr != nil {
|
||||
if containerErr.Error != nil && (containerErr.Error.Code != nil && *containerErr.Error.Code == "unsupported_operation") {
|
||||
t.Logf("[EXPECTED] Provider %s returned unsupported operation error for container creation", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
t.Fatalf("❌ ContainerCreate (setup) failed: %v", GetErrorMessage(containerErr))
|
||||
}
|
||||
|
||||
if containerResponse == nil || containerResponse.ID == "" {
|
||||
t.Fatal("❌ ContainerCreate (setup) returned nil or empty response")
|
||||
}
|
||||
|
||||
containerID := containerResponse.ID
|
||||
defer func() {
|
||||
// Clean up container
|
||||
deleteRequest := &schemas.BifrostContainerDeleteRequest{
|
||||
Provider: testConfig.Provider,
|
||||
ContainerID: containerID,
|
||||
}
|
||||
_, _ = client.ContainerDeleteRequest(bfCtx, deleteRequest)
|
||||
}()
|
||||
|
||||
// Create a file in the container
|
||||
testContent := []byte("Test content for file delete")
|
||||
filePath := "/test-file-delete.txt"
|
||||
|
||||
fileCreateRequest := &schemas.BifrostContainerFileCreateRequest{
|
||||
Provider: testConfig.Provider,
|
||||
ContainerID: containerID,
|
||||
File: testContent,
|
||||
Path: &filePath,
|
||||
}
|
||||
|
||||
fileCreateResponse, fileCreateErr := client.ContainerFileCreateRequest(bfCtx, fileCreateRequest)
|
||||
if fileCreateErr != nil {
|
||||
if fileCreateErr.Error != nil && (fileCreateErr.Error.Code != nil && *fileCreateErr.Error.Code == "unsupported_operation") {
|
||||
t.Logf("[EXPECTED] Provider %s returned unsupported operation error for file creation", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
t.Fatalf("❌ ContainerFileCreate (setup) failed: %v", GetErrorMessage(fileCreateErr))
|
||||
}
|
||||
|
||||
if fileCreateResponse == nil {
|
||||
t.Fatal("❌ ContainerFileCreate (setup) returned nil response with no error")
|
||||
}
|
||||
|
||||
fileID := fileCreateResponse.ID
|
||||
|
||||
// Now delete the file
|
||||
deleteRequest := &schemas.BifrostContainerFileDeleteRequest{
|
||||
Provider: testConfig.Provider,
|
||||
ContainerID: containerID,
|
||||
FileID: fileID,
|
||||
}
|
||||
|
||||
response, err := client.ContainerFileDeleteRequest(bfCtx, deleteRequest)
|
||||
|
||||
if err != nil {
|
||||
if err.Error != nil && (err.Error.Code != nil && *err.Error.Code == "unsupported_operation") {
|
||||
t.Logf("[EXPECTED] Provider %s returned unsupported operation error", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
t.Fatalf("❌ ContainerFileDelete failed: %v", GetErrorMessage(err))
|
||||
}
|
||||
|
||||
if response == nil {
|
||||
t.Fatal("❌ ContainerFileDelete returned nil response")
|
||||
}
|
||||
|
||||
if !response.Deleted {
|
||||
t.Fatal("❌ ContainerFileDelete returned deleted=false")
|
||||
}
|
||||
|
||||
t.Logf("✅ Container File Delete test passed for provider: %s, file ID: %s", testConfig.Provider, fileID)
|
||||
})
|
||||
}
|
||||
|
||||
// RunContainerFileUnsupportedTest tests that providers correctly return unsupported operation errors for container file operations
|
||||
func RunContainerFileUnsupportedTest(t *testing.T, client *bifrost.Bifrost, ctx context.Context, testConfig ComprehensiveTestConfig) {
|
||||
// Only run this test if none of the container file operations are supported
|
||||
if testConfig.Scenarios.ContainerFileCreate || testConfig.Scenarios.ContainerFileList ||
|
||||
testConfig.Scenarios.ContainerFileRetrieve || testConfig.Scenarios.ContainerFileContent ||
|
||||
testConfig.Scenarios.ContainerFileDelete {
|
||||
t.Logf("[SKIPPED] Container File Unsupported: Provider %s supports container file operations", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
|
||||
// Also skip if container operations themselves are not supported (can't test file ops without containers)
|
||||
if !testConfig.Scenarios.ContainerCreate {
|
||||
t.Logf("[SKIPPED] Container File Unsupported: Provider %s does not support container operations", testConfig.Provider)
|
||||
return
|
||||
}
|
||||
|
||||
t.Run("ContainerFileUnsupported", func(t *testing.T) {
|
||||
t.Logf("[RUNNING] Container File Unsupported test for provider: %s", testConfig.Provider)
|
||||
|
||||
bfCtx := schemas.NewBifrostContext(ctx, schemas.NoDeadline)
|
||||
|
||||
// Test ContainerFileCreate returns unsupported
|
||||
testContent := []byte("Test content")
|
||||
filePath := "/test.txt"
|
||||
createRequest := &schemas.BifrostContainerFileCreateRequest{
|
||||
Provider: testConfig.Provider,
|
||||
ContainerID: "test-container-id",
|
||||
File: testContent,
|
||||
Path: &filePath,
|
||||
}
|
||||
_, createErr := client.ContainerFileCreateRequest(bfCtx, createRequest)
|
||||
|
||||
if createErr == nil {
|
||||
t.Fatal("❌ Expected unsupported operation error for ContainerFileCreate, got nil")
|
||||
}
|
||||
|
||||
if createErr.Error == nil || createErr.Error.Code == nil || *createErr.Error.Code != "unsupported_operation" {
|
||||
t.Fatalf("❌ Expected unsupported_operation error code, got: %v", createErr)
|
||||
}
|
||||
|
||||
t.Logf("✅ Container File Unsupported test passed for provider: %s", testConfig.Provider)
|
||||
})
|
||||
}
|
||||
Reference in New Issue
Block a user