mirror of https://github.com/knative/func.git
122 lines
2.7 KiB
Go
122 lines
2.7 KiB
Go
//go:build !integration
|
|
// +build !integration
|
|
|
|
package functions
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
|
|
. "knative.dev/func/pkg/testing"
|
|
)
|
|
|
|
// TestInstances_LocalErrors tests the three possible error states for a function
|
|
// when attempting to access a local instance.
|
|
func TestInstances_LocalErrors(t *testing.T) {
|
|
root, rm := Mktemp(t)
|
|
defer rm()
|
|
|
|
// Create a function that will not be running
|
|
f, err := New().Init(Function{Runtime: "go", Root: root})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
f Function
|
|
wantIs error
|
|
wantAs any
|
|
}{
|
|
{
|
|
name: "Not running", // Function exists but is not running
|
|
f: f,
|
|
wantIs: ErrNotRunning,
|
|
},
|
|
{
|
|
name: "Not initialized", // A function directory is provided, but no function exists
|
|
f: Function{Root: "testdata/not-initialized"},
|
|
wantAs: &ErrNotInitialized{},
|
|
},
|
|
{
|
|
name: "Root required", // No root directory is provided
|
|
f: Function{},
|
|
wantIs: ErrRootRequired,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
i := InstanceRefs{}
|
|
_, err := i.Local(context.Background(), tt.f)
|
|
if tt.wantIs != nil && !errors.Is(err, tt.wantIs) {
|
|
t.Errorf("Local() error = %v, want %#v", err, tt.wantIs)
|
|
}
|
|
if tt.wantAs != nil && !errors.As(err, tt.wantAs) {
|
|
t.Errorf("Local() error = %v, want %#v", err, tt.wantAs)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestInstance_RemoteErrors tests the possible error states for a function when
|
|
// attempting to access a remote instance.
|
|
func TestInstance_RemoteErrors(t *testing.T) {
|
|
root, rm := Mktemp(t)
|
|
defer rm()
|
|
|
|
// Create a function that will not be running
|
|
_, err := New().Init(Function{Runtime: "go", Namespace: "ns1", Root: root})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Load the function
|
|
if _, err := NewFunction(root); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
var nameRequired = "requires function name"
|
|
var nsRequired = "requires namespace"
|
|
|
|
tests := []struct {
|
|
test string
|
|
name string
|
|
namespace string
|
|
want string
|
|
}{
|
|
{
|
|
test: "missing namespace",
|
|
name: "foo",
|
|
namespace: "",
|
|
want: nsRequired,
|
|
},
|
|
{
|
|
test: "missing name",
|
|
name: "",
|
|
namespace: "ns",
|
|
want: nameRequired,
|
|
},
|
|
{
|
|
test: "missing both",
|
|
name: "",
|
|
namespace: "",
|
|
want: nameRequired,
|
|
},
|
|
}
|
|
for _, test := range tests {
|
|
t.Run(test.test, func(t *testing.T) {
|
|
i := InstanceRefs{}
|
|
_, err := i.Remote(context.Background(), test.name, test.namespace)
|
|
if err == nil {
|
|
t.Fatal("did not receive expected error")
|
|
}
|
|
if !strings.Contains(err.Error(), test.want) {
|
|
t.Errorf("expected error to contain '%v', got '%v'", test.want, err)
|
|
}
|
|
})
|
|
}
|
|
|
|
}
|