136 lines
3.9 KiB
Go
136 lines
3.9 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"testing"
|
|
"time"
|
|
|
|
messages "git.tornberg.me/go-cart-actor/proto"
|
|
"google.golang.org/grpc"
|
|
)
|
|
|
|
// TestCartActorMutationAndState validates end-to-end gRPC mutation + state retrieval
|
|
// against a locally started gRPC server (single-node scenario).
|
|
// This test uses AddItemType directly to avoid hitting external product
|
|
// fetching logic (FetchItem) which would require network I/O.
|
|
func TestCartActorMutationAndState(t *testing.T) {
|
|
// Setup local grain pool + synced pool (no discovery, single host)
|
|
pool := NewGrainLocalPool(1024, time.Minute, spawn)
|
|
synced, err := NewSyncedPool(pool, "127.0.0.1", nil)
|
|
if err != nil {
|
|
t.Fatalf("NewSyncedPool error: %v", err)
|
|
}
|
|
|
|
// Start gRPC server (CartActor + ControlPlane) on :1337
|
|
grpcSrv, err := StartGRPCServer(":1337", pool, synced)
|
|
if err != nil {
|
|
t.Fatalf("StartGRPCServer error: %v", err)
|
|
}
|
|
defer grpcSrv.GracefulStop()
|
|
|
|
// Dial the local server
|
|
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
|
|
defer cancel()
|
|
conn, err := grpc.DialContext(ctx, "127.0.0.1:1337",
|
|
grpc.WithInsecure(),
|
|
grpc.WithBlock(),
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("grpc.Dial error: %v", err)
|
|
}
|
|
defer conn.Close()
|
|
|
|
cartClient := messages.NewCartActorClient(conn)
|
|
|
|
// Create a short cart id (<=16 chars so it fits into the fixed CartId 16-byte array cleanly)
|
|
cartID := fmt.Sprintf("cart-%d", time.Now().UnixNano())
|
|
|
|
// Build an AddItem payload (bypasses FetchItem to keep test deterministic)
|
|
addItem := &messages.AddItem{
|
|
ItemId: 1,
|
|
Quantity: 1,
|
|
Price: 1000,
|
|
OrgPrice: 1000,
|
|
Sku: "test-sku",
|
|
Name: "Test SKU",
|
|
Image: "/img.png",
|
|
Stock: 2, // InStock
|
|
Tax: 2500,
|
|
Country: "se",
|
|
}
|
|
|
|
// Marshal underlying mutation payload using the existing handler code path
|
|
handler, ok := Handlers[AddItemType]
|
|
if !ok {
|
|
t.Fatalf("Handler for AddItemType missing")
|
|
}
|
|
payloadData, err := getSerializedPayload(handler, AddItemType, addItem)
|
|
if err != nil {
|
|
t.Fatalf("serialize add item: %v", err)
|
|
}
|
|
|
|
// Issue Mutate RPC
|
|
mutResp, err := cartClient.Mutate(context.Background(), &messages.MutationRequest{
|
|
CartId: cartID,
|
|
Type: messages.MutationType(AddItemType),
|
|
Payload: payloadData,
|
|
ClientTimestamp: time.Now().Unix(),
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("Mutate RPC error: %v", err)
|
|
}
|
|
if mutResp.StatusCode != 200 {
|
|
t.Fatalf("Mutate returned non-200 status: %d payload=%s", mutResp.StatusCode, string(mutResp.Payload))
|
|
}
|
|
|
|
// Decode cart state JSON and validate
|
|
state := &CartGrain{}
|
|
if err := json.Unmarshal(mutResp.Payload, state); err != nil {
|
|
t.Fatalf("Unmarshal mutate cart state: %v\nPayload: %s", err, string(mutResp.Payload))
|
|
}
|
|
if len(state.Items) != 1 {
|
|
t.Fatalf("Expected 1 item after mutation, got %d", len(state.Items))
|
|
}
|
|
if state.Items[0].Sku != "test-sku" {
|
|
t.Fatalf("Unexpected item SKU: %s", state.Items[0].Sku)
|
|
}
|
|
|
|
// Issue GetState RPC
|
|
getResp, err := cartClient.GetState(context.Background(), &messages.StateRequest{
|
|
CartId: cartID,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("GetState RPC error: %v", err)
|
|
}
|
|
if getResp.StatusCode != 200 {
|
|
t.Fatalf("GetState returned non-200 status: %d payload=%s", getResp.StatusCode, string(getResp.Payload))
|
|
}
|
|
|
|
state2 := &CartGrain{}
|
|
if err := json.Unmarshal(getResp.Payload, state2); err != nil {
|
|
t.Fatalf("Unmarshal get state: %v", err)
|
|
}
|
|
if len(state2.Items) != 1 {
|
|
t.Fatalf("Expected 1 item in GetState, got %d", len(state2.Items))
|
|
}
|
|
if state2.Items[0].Sku != "test-sku" {
|
|
t.Fatalf("Unexpected SKU in GetState: %s", state2.Items[0].Sku)
|
|
}
|
|
}
|
|
|
|
// getSerializedPayload serializes a mutation proto using the registered handler.
|
|
func getSerializedPayload(handler MessageHandler, msgType uint16, content interface{}) ([]byte, error) {
|
|
msg := &Message{
|
|
Type: msgType,
|
|
Content: content,
|
|
}
|
|
var buf bytes.Buffer
|
|
if err := handler.Write(msg, &buf); err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|