You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
virt/agent/api/network_observations_test.go

211 lines
7.3 KiB
Go

package api
import (
"context"
"encoding/json"
"net/http"
"sync"
"testing"
"git.luoli.live/root/virt/agent/auth"
"git.luoli.live/root/virt/agent/hypervisor"
"git.luoli.live/root/virt/agent/networkobserve"
)
const testObservationGeneration = "0123456789abcdef0123456789abcdef"
type recordingNetworkObserver struct {
mu sync.Mutex
generation string
capability networkobserve.Capability
lastAfter uint64
lastLimit int
calls int
}
func (observer *recordingNetworkObserver) Generation() string { return observer.generation }
func (observer *recordingNetworkObserver) Capability() networkobserve.Capability {
return observer.capability
}
func (observer *recordingNetworkObserver) Batch(after uint64, limit int) (networkobserve.Batch, error) {
observer.mu.Lock()
observer.lastAfter = after
observer.lastLimit = limit
observer.calls++
observer.mu.Unlock()
return networkobserve.Batch{
ContractVersion: networkobserve.ContractVersion,
CollectorGeneration: observer.generation,
Capability: observer.capability,
}, nil
}
func availableObservationCapability() networkobserve.Capability {
return networkobserve.Capability{
Name: networkobserve.CapabilityName, ContractVersion: networkobserve.ContractVersion,
Available: true, NoPayload: true, IPv4: true, IPv6: true, Conntrack: true,
PolicyDecisions: false, BucketSeconds: networkobserve.BucketSeconds,
}
}
func (*testHypervisor) Capabilities(context.Context) (hypervisor.Capabilities, error) {
return hypervisor.Capabilities{Backend: "test"}, nil
}
func TestNetworkObservationRouteRequiresExactSuperAdminActor(t *testing.T) {
api := newTestAPI(t)
observer := &recordingNetworkObserver{
generation: testObservationGeneration,
capability: availableObservationCapability(),
}
if err := api.handler.SetNetworkObserver(observer); err != nil {
t.Fatal(err)
}
for _, actor := range []auth.Actor{
{UserID: 1, CanManage: true},
{UserID: 1, IsSuperAdmin: true},
{UserID: 0, IsSuperAdmin: true, CanManage: true},
} {
response := api.request(t, http.MethodGet, "/v1/network-observations", nil, actor)
if response.Code != http.StatusForbidden {
t.Fatalf("actor %#v status=%d body=%s", actor, response.Code, response.Body.String())
}
}
if observer.calls != 0 {
t.Fatalf("unauthorized requests reached observer: %d", observer.calls)
}
}
func TestNetworkObservationIsOptionalAndUnavailableWithoutCollector(t *testing.T) {
api := newTestAPI(t)
actor := auth.Actor{UserID: 1, IsSuperAdmin: true, CanManage: true}
response := api.request(t, http.MethodGet, "/v1/network-observations", nil, actor)
if response.Code != http.StatusServiceUnavailable {
t.Fatalf("observation status=%d body=%s", response.Code, response.Body.String())
}
capabilities := api.request(t, http.MethodGet, "/v1/capabilities", nil, auth.Actor{UserID: 1})
if capabilities.Code != http.StatusOK {
t.Fatalf("capability status=%d body=%s", capabilities.Code, capabilities.Body.String())
}
var payload map[string]json.RawMessage
if err := json.Unmarshal(capabilities.Body.Bytes(), &payload); err != nil {
t.Fatal(err)
}
if _, exists := payload["network_abuse_observation"]; exists {
t.Fatalf("unconfigured optional capability leaked into response: %s", capabilities.Body.String())
}
}
func TestNetworkObservationRouteResetsOnlyStaleGenerationCursor(t *testing.T) {
api := newTestAPI(t)
observer := &recordingNetworkObserver{
generation: testObservationGeneration,
capability: availableObservationCapability(),
}
if err := api.handler.SetNetworkObserver(observer); err != nil {
t.Fatal(err)
}
actor := auth.Actor{UserID: 1, IsSuperAdmin: true, CanManage: true}
response := api.request(t, http.MethodGet,
"/v1/network-observations?generation=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa&after_cursor=77&limit=12",
nil, actor)
if response.Code != http.StatusOK {
t.Fatalf("stale generation status=%d body=%s", response.Code, response.Body.String())
}
if observer.lastAfter != 0 || observer.lastLimit != 12 {
t.Fatalf("stale generation request = after %d limit %d", observer.lastAfter, observer.lastLimit)
}
response = api.request(t, http.MethodGet,
"/v1/network-observations?generation="+testObservationGeneration+"&after_cursor=77&limit=4",
nil, actor)
if response.Code != http.StatusOK {
t.Fatalf("current generation status=%d body=%s", response.Code, response.Body.String())
}
if observer.lastAfter != 77 || observer.lastLimit != 4 {
t.Fatalf("current generation request = after %d limit %d", observer.lastAfter, observer.lastLimit)
}
}
func TestNetworkObservationRouteEncodesEmptyWindowsAsJSONArray(t *testing.T) {
api := newTestAPI(t)
observer := &recordingNetworkObserver{
generation: testObservationGeneration,
capability: availableObservationCapability(),
}
if err := api.handler.SetNetworkObserver(observer); err != nil {
t.Fatal(err)
}
actor := auth.Actor{UserID: 1, IsSuperAdmin: true, CanManage: true}
response := api.request(t, http.MethodGet, "/v1/network-observations", nil, actor)
if response.Code != http.StatusOK {
t.Fatalf("observation status=%d body=%s", response.Code, response.Body.String())
}
var payload map[string]json.RawMessage
if err := json.Unmarshal(response.Body.Bytes(), &payload); err != nil {
t.Fatal(err)
}
if got := string(payload["windows"]); got != "[]" {
t.Fatalf("empty observation windows encoded as %s, want []", got)
}
}
func TestNetworkObservationQueryIsStrictAndBounded(t *testing.T) {
api := newTestAPI(t)
observer := &recordingNetworkObserver{
generation: testObservationGeneration,
capability: availableObservationCapability(),
}
if err := api.handler.SetNetworkObserver(observer); err != nil {
t.Fatal(err)
}
actor := auth.Actor{UserID: 1, IsSuperAdmin: true, CanManage: true}
for _, target := range []string{
"/v1/network-observations?after_cursor=1",
"/v1/network-observations?limit=0",
"/v1/network-observations?limit=65",
"/v1/network-observations?limit=1&limit=2",
"/v1/network-observations?unknown=1",
"/v1/network-observations?generation=ABCDEF",
"/v1/network-observations?generation=",
"/v1/network-observations?after_cursor=",
"/v1/network-observations?limit=",
} {
response := api.request(t, http.MethodGet, target, nil, actor)
if response.Code != http.StatusUnprocessableEntity {
t.Fatalf("target %q status=%d body=%s", target, response.Code, response.Body.String())
}
}
if observer.calls != 0 {
t.Fatalf("invalid requests reached observer: %d", observer.calls)
}
}
func TestCapabilitiesAdvertiseOptionalObservationWithoutSchedulingGate(t *testing.T) {
api := newTestAPI(t)
observer := &recordingNetworkObserver{
generation: testObservationGeneration,
capability: availableObservationCapability(),
}
if err := api.handler.SetNetworkObserver(observer); err != nil {
t.Fatal(err)
}
response := api.request(t, http.MethodGet, "/v1/capabilities", nil, auth.Actor{UserID: 1})
if response.Code != http.StatusOK {
t.Fatalf("capability status=%d body=%s", response.Code, response.Body.String())
}
var payload struct {
Backend string `json:"backend"`
Observation networkobserve.Capability `json:"network_abuse_observation"`
}
if err := json.Unmarshal(response.Body.Bytes(), &payload); err != nil {
t.Fatal(err)
}
if payload.Backend != "test" || payload.Observation != observer.capability {
t.Fatalf("capability response=%#v", payload)
}
}