180 lines
4.6 KiB
Go
180 lines
4.6 KiB
Go
package sandbox
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"testing"
|
|
)
|
|
|
|
func TestRemoteBindingDecision(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
name string
|
|
err error
|
|
replace bool
|
|
preserve bool
|
|
}{
|
|
{name: "nil", err: nil},
|
|
{
|
|
name: "not found",
|
|
err: NewRemoteError(SandboxTypeCube, "Get", RemoteErrorKindNotFound, "gone", nil),
|
|
replace: true,
|
|
preserve: false,
|
|
},
|
|
{
|
|
name: "terminal",
|
|
err: NewRemoteError(SandboxTypeCube, "Get", RemoteErrorKindTerminal, "terminated", nil),
|
|
replace: true,
|
|
preserve: false,
|
|
},
|
|
{
|
|
name: "authentication",
|
|
err: NewRemoteError(SandboxTypeCube, "Connect", RemoteErrorKindAuthentication, "denied", nil),
|
|
preserve: true,
|
|
},
|
|
{
|
|
name: "invalid request",
|
|
err: NewRemoteError(SandboxTypeCube, "Create", RemoteErrorKindInvalidRequest, "bad template", nil),
|
|
preserve: true,
|
|
},
|
|
{
|
|
name: "unsupported",
|
|
err: NewRemoteError(SandboxTypeCube, "Connect", RemoteErrorKindUnsupported, "no reconnect", nil),
|
|
preserve: true,
|
|
},
|
|
{
|
|
name: "conflict",
|
|
err: NewRemoteError(SandboxTypeCube, "Delete", RemoteErrorKindConflict, "busy", nil),
|
|
preserve: true,
|
|
},
|
|
{
|
|
name: "capacity",
|
|
err: NewRemoteError(SandboxTypeCube, "Create", RemoteErrorKindCapacity, "full", nil),
|
|
preserve: true,
|
|
},
|
|
{
|
|
name: "timeout",
|
|
err: NewRemoteError(SandboxTypeCube, "Get", RemoteErrorKindTimeout, "deadline", nil),
|
|
preserve: true,
|
|
},
|
|
{
|
|
name: "unavailable",
|
|
err: NewRemoteError(SandboxTypeCube, "Health", RemoteErrorKindUnavailable, "offline", nil),
|
|
preserve: true,
|
|
},
|
|
{
|
|
name: "internal",
|
|
err: NewRemoteError(SandboxTypeCube, "List", RemoteErrorKindInternal, "unknown", nil),
|
|
preserve: true,
|
|
},
|
|
{
|
|
name: "wrapped terminal",
|
|
err: fmt.Errorf("probe failed: %w", NewRemoteError(SandboxTypeCube, "Get", RemoteErrorKindTerminal, "dead", nil)),
|
|
replace: true,
|
|
preserve: false,
|
|
},
|
|
{
|
|
name: "unclassified defaults to preserve",
|
|
err: errors.New("provider returned an unknown error"),
|
|
preserve: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
if got := CanReplaceRemoteBinding(tt.err); got != tt.replace {
|
|
t.Fatalf("CanReplaceRemoteBinding() = %v, want %v", got, tt.replace)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestRemoteErrorRetainsCause(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
cause := errors.New("connection reset")
|
|
err := NewRemoteError(
|
|
SandboxTypeCube,
|
|
"Connect",
|
|
RemoteErrorKindUnavailable,
|
|
"control plane unavailable",
|
|
cause,
|
|
)
|
|
|
|
if !errors.Is(err, cause) {
|
|
t.Fatal("RemoteError must retain its provider-native cause")
|
|
}
|
|
if got, want := err.Error(), "cube Connect: unavailable: control plane unavailable: connection reset"; got != want {
|
|
t.Fatalf("Error() = %q, want %q", got, want)
|
|
}
|
|
}
|
|
|
|
func TestRemoteErrorDiagnostics(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
remote := NewRemoteError(
|
|
SandboxTypeCube, "Exec", RemoteErrorKindAuthentication,
|
|
"HTTP 403", errors.New("forbidden"),
|
|
)
|
|
remote.StatusCode = 403
|
|
got := RemoteErrorDiagnostics(remote)
|
|
if got != "authentication op=Exec http=403 HTTP 403" {
|
|
t.Fatalf("RemoteErrorDiagnostics() = %q", got)
|
|
}
|
|
if RemoteErrorDiagnostics(errors.New("plain")) != "plain" {
|
|
t.Fatal("expected plain error text")
|
|
}
|
|
}
|
|
|
|
func TestIsRemoteDirAlreadyExists(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
cubeSeedErr := NewRemoteError(
|
|
SandboxTypeCube, "MakeDir", RemoteErrorKindInternal,
|
|
"failed to make dir /opt/weknora/tenant/skills/sk-1: directory already exists: /opt/weknora/tenant/skills/sk-1",
|
|
nil,
|
|
)
|
|
tests := []struct {
|
|
name string
|
|
err error
|
|
want bool
|
|
}{
|
|
{name: "nil", err: nil, want: false},
|
|
{name: "cube envd already exists", err: cubeSeedErr, want: true},
|
|
{
|
|
name: "wrapped cube error",
|
|
err: fmt.Errorf("sandbox: create install directory: %w", cubeSeedErr),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "e2b conflict already exists",
|
|
err: NewRemoteError(
|
|
SandboxTypeE2B, "MakeDir", RemoteErrorKindConflict, "already exists", nil,
|
|
),
|
|
want: true,
|
|
},
|
|
{
|
|
name: "unrelated internal",
|
|
err: NewRemoteError(SandboxTypeCube, "MakeDir", RemoteErrorKindInternal, "disk full", nil),
|
|
want: false,
|
|
},
|
|
{
|
|
name: "conflict without already exists",
|
|
err: NewRemoteError(SandboxTypeCube, "Delete", RemoteErrorKindConflict, "busy", nil),
|
|
want: false,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
tt := tt
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
if got := IsRemoteDirAlreadyExists(tt.err); got != tt.want {
|
|
t.Fatalf("IsRemoteDirAlreadyExists() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|