mirror of https://github.com/knative/func.git
100 lines
3.0 KiB
Go
100 lines
3.0 KiB
Go
//go:build !integration
|
|
// +build !integration
|
|
|
|
package functions
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"testing"
|
|
|
|
. "knative.dev/func/pkg/testing"
|
|
)
|
|
|
|
// TestJob_New ensures that creating a new Job creates the expected errors if
|
|
// incomplete and the client registers the job as being available for the
|
|
// function when created.
|
|
//
|
|
// This is ver much a unit test mostly confirming implementation details, the
|
|
// more complete test is the integration test which invokes "run". Presuming
|
|
// this works for both containerized and noncontainerized funcitions, the
|
|
// correctness of the Job implementation is inferred (with the possible
|
|
// exception of not cleaning up after itself, which is an implementatoin best
|
|
// left to unit tests here).
|
|
func TestJob_New(t *testing.T) {
|
|
root, rm := Mktemp(t)
|
|
defer rm()
|
|
client := New()
|
|
|
|
// create a new function
|
|
f, err := client.Init(Function{Runtime: "go", Root: root})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Assert that an initialized function and port are required
|
|
onStop := func() error { return nil }
|
|
if _, err := NewJob(Function{}, "127.0.0.1", "8080", nil, onStop, false); err == nil {
|
|
t.Fatal("expected NewJob to require an initialized functoin")
|
|
}
|
|
if _, err := NewJob(f, "127.0.0.1", "", nil, onStop, false); err == nil {
|
|
t.Fatal("expected NewJob to require a port")
|
|
}
|
|
|
|
// Assert creating a Job with the required arguments succeeds.
|
|
_, err = NewJob(f, "127.0.0.1", "8080", nil, onStop, false)
|
|
if err != nil {
|
|
t.Fatalf("creating job failed. %s", err)
|
|
}
|
|
|
|
// Assert that the client recognizes a job is running for the given function
|
|
// NOTE: the Instances API will be updated to return []Instance to reflect
|
|
// that the system supports multiple instances running simultaneously.
|
|
_, err = client.Instances().Local(context.Background(), f)
|
|
if err != nil {
|
|
if errors.Is(err, ErrNotRunning) {
|
|
t.Fatalf("client does not recognize job as running. %s", err)
|
|
} else {
|
|
t.Fatalf("unexpected error checking client for instance's existence. %s", err)
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// TestJob_Stop ensures that stopping a local job results in the API no longer
|
|
// recognizing it as running, and invokes the onStop function
|
|
func TestJob_Stop(t *testing.T) {
|
|
root, rm := Mktemp(t)
|
|
defer rm()
|
|
client := New()
|
|
|
|
f, err := client.Init(Function{Runtime: "go", Root: root})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Assert that an initialized function and port are required
|
|
var onStopInvoked bool
|
|
onStop := func() error { onStopInvoked = true; return nil }
|
|
|
|
// Assert creating a Job with the required arguments succeeds.
|
|
j, err := NewJob(f, "127.0.0.1", "8080", nil, onStop, false)
|
|
if err != nil {
|
|
t.Fatalf("creating job failed. %s", err)
|
|
}
|
|
_, err = client.Instances().Local(context.Background(), f)
|
|
if err != nil {
|
|
if errors.Is(err, ErrNotRunning) {
|
|
t.Fatalf("client does not recognize job as running. %s", err)
|
|
} else {
|
|
t.Fatalf("unexpected error checking client for instance's existence. %s", err)
|
|
}
|
|
}
|
|
if err := j.Stop(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !onStopInvoked {
|
|
t.Fatal("the job stopped but did not invoke the onStop handler")
|
|
}
|
|
}
|