chore: more tests

Signed-off-by: Lucas Fontes <[email protected]>

Author: lxfontes

wasmbus/control/api.go

@@ -8,6 +8,8 @@ import (
 	"time"
 )
 
+// Lattice Control
+// https://wasmcloud.com/docs/reference/nats#control-interface
 type APIv1 interface {
 	ProviderAuction(ctx context.Context, req *ProviderAuctionRequest) (*ProviderAuctionResponse, error)
 	ComponentAuction(ctx context.Context, req *ComponentAuctionRequest) (*ComponentAuctionResponse, error)
@@ -37,14 +39,18 @@ type APIv1 interface {
 	HostPing(ctx context.Context, req *HostPingRequest) (*HostPingResponse, error)
 }
 
+// Response is a generic response type for the control interface.
+// All API Responses have the same structure.
 type Response[T any] struct {
 	Success  bool   `json:"success"`
 	Message  string `json:"message"`
 	Response T      `json:"response"`
 }
 
 type ProviderAuctionRequest struct {
-	Constraints map[string]string `json:"constraints,omitempty"`
+	// Constraints are key-value pairs that are used to filter hosts.
+	// Required even if empty (unfortunately).
+	Constraints map[string]string `json:"constraints"`
 	ProviderId  string            `json:"provider_id,omitempty"`
 	ProviderRef string            `json:"provider_ref,omitempty"`
 }
@@ -59,7 +65,9 @@ type ProviderAuctionResponsePayload struct {
 type ProviderAuctionResponse = Response[ProviderAuctionResponsePayload]
 
 type ComponentAuctionRequest struct {
-	Constraints  map[string]string `json:"constraints,omitempty"`
+	// Constraints are key-value pairs that are used to filter hosts.
+	// Required even if empty (unfortunately).
+	Constraints  map[string]string `json:"constraints"`
 	ComponentId  string            `json:"component_id,omitempty"`
 	ComponentRef string            `json:"component_ref,omitempty"`
 }
@@ -89,8 +97,9 @@ type ScaleComponentResponsePayload struct {
 type ScaleComponentResponse = Response[ScaleComponentResponsePayload]
 
 type UpdateComponentRequest struct {
+	HostId string `json:"-"`
+
 	ComponentId     string            `json:"component_id"`
-	HostId          string            `json:"host_id"`
 	NewComponentRef string            `json:"new_component_ref"`
 	Annotations     map[string]string `json:"annotations,omitempty"`
 }
@@ -271,7 +280,10 @@ type HostInventoryResponsePayload struct {
 
 type HostInventoryResponse = Response[HostInventoryResponsePayload]
 
+// HostPingRequest is a special case where the request is not sent to a specific host.
+// This is because the request is a scatter/gather pattern where the response is composed client side.
 type HostPingRequest struct {
+	// Wait is the duration to wait before returning the response.
 	Wait time.Duration `json:"-"`
 }
 
@@ -287,7 +299,7 @@ type HostPingResponsePayload struct {
 	UptimeHuman   string            `json:"uptime_human"`
 }
 
-// NOTE(lxf): Needed cause this is a scatter/gather api.
+// NOTE(lxf): Needed cause this is a scatter/gather api and the response is composed client side.
 type HostPingSingleResponse = Response[HostPingResponsePayload]
 
 type HostPingResponse = Response[[]HostPingResponsePayload]

wasmbus/control/client.go

@@ -13,8 +13,9 @@ type Client struct {
 	lattice string
 }
 
-//var _ APIv1 = (*Client)(nil)
+var _ APIv1 = (*Client)(nil)
 
+// NewClient creates a new control client for a given lattice
 func NewClient(bus wasmbus.Bus, lattice string) *Client {
 	return &Client{
 		Bus:     bus,

wasmbus/control/client_test.go

@@ -3,26 +3,114 @@ package control
 import (
 	"context"
 	"testing"
+	"time"
 
-	"github.com/nats-io/nats.go"
 	"go.wasmcloud.dev/wasmbus"
+	"go.wasmcloud.dev/wasmbus/wasmbustest"
 )
 
 func TestClient(t *testing.T) {
-	nc, err := nats.Connect(nats.DefaultURL)
+	nc, teardown := wasmbustest.WithWash(t)
+	defer teardown(t)
+
+	bus := wasmbus.NewNatsBus(nc)
+	c := NewClient(bus, "default")
+
+	t.Run("component", wrapTest(testComponent, c))
+	t.Run("provider", wrapTest(testProvider, c))
+
+}
+
+func wrapTest(f func(*testing.T, *Client), c *Client) func(*testing.T) {
+	return func(t *testing.T) {
+		f(t, c)
+	}
+}
+
+func testProvider(t *testing.T, c *Client) {
+	req := &ProviderAuctionRequest{
+		ProviderId:  "test-provider",
+		ProviderRef: wasmbustest.ValidProvider,
+		Constraints: make(map[string]string),
+	}
+
+	resp, err := c.ProviderAuction(context.TODO(), req)
 	if err != nil {
-		t.Fatal(err)
+		t.Fatalf("failed to auction: %v", err)
 	}
 
-	bus := wasmbus.NewNatsBus(nc)
-	client := NewClient(bus, "default")
-	t.Log("Client created")
+	if !resp.Success {
+		t.Fatalf("auction failed: %v", resp)
+	}
+
+	if resp.Response.HostId == "" {
+		t.Fatalf("host id is empty")
+	}
+
+	reqStart := &ProviderStartRequest{
+		HostId:      resp.Response.HostId,
+		ProviderId:  req.ProviderId,
+		ProviderRef: req.ProviderRef,
+	}
 
-	resp, err := client.ConfigGet(context.Background(), &ConfigGetRequest{
-		Name: "test",
-	})
+	startResp, err := c.ProviderStart(context.TODO(), reqStart)
 	if err != nil {
-		t.Fatal(err)
+		t.Fatalf("failed to start: %v", err)
+	}
+
+	if !startResp.Success {
+		t.Fatalf("start failed: %v", startResp)
+	}
+}
+
+func testComponent(t *testing.T, c *Client) {
+	// we first need an auction to find the host id
+
+	auctionReq := &ComponentAuctionRequest{
+		ComponentId:  "test-component",
+		ComponentRef: wasmbustest.ValidComponent,
+		Constraints:  make(map[string]string),
+	}
+
+	auctionResp, err := c.ComponentAuction(context.TODO(), auctionReq)
+	if err != nil {
+		t.Fatalf("failed to auction: %v", err)
+	}
+
+	scaleReq := &ScaleComponentRequest{
+		HostId:       auctionResp.Response.HostId,
+		ComponentId:  auctionReq.ComponentId,
+		ComponentRef: auctionReq.ComponentRef,
+		Count:        1,
+	}
+
+	scaleResp, err := c.ScaleComponent(context.TODO(), scaleReq)
+	if err != nil {
+		t.Fatalf("failed to scale: %v", err)
+	}
+
+	if !scaleResp.Success {
+		t.Fatalf("scale failed: %v", scaleResp)
+	}
+
+	// NOTE(lxf): it takes time for the component to be ready
+	// and the only way to know is to watch for lattice events.
+	// For now, we'll just sleep for a bit.
+	<-time.After(1 * time.Second)
+
+	updateReq := &UpdateComponentRequest{
+		HostId:          auctionResp.Response.HostId,
+		ComponentId:     auctionReq.ComponentId,
+		NewComponentRef: auctionReq.ComponentRef,
+		Annotations:     map[string]string{"test": "test"},
+	}
+
+	updateResp, err := c.UpdateComponent(context.TODO(), updateReq)
+	if err != nil {
+		t.Fatalf("failed to update: %v", err)
+	}
+
+	if !updateResp.Success {
+		t.Fatalf("update failed: %v", updateResp)
 	}
-	t.Log(resp)
 }