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.
211 lines
7.3 KiB
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)
|
|
}
|
|
}
|