add tests + basic LRO service

Author: toumorokoshi

buf.gen.yaml

@@ -1,14 +1,22 @@
-version: v1
+version: v2
+managed:
+  enabled: true
+  override:
+    # temporary workaround until https://github.com/aep-dev/aep-components/pull/22
+    # is merged and released
+    - module: buf.build/aep/api
+      file_option: go_package_prefix
+      value: buf.build/gen/go/aep/api/protocolbuffers/go
 plugins:
-  - plugin: buf.build/protocolbuffers/go:v1.31.0
+  - remote: buf.build/protocolbuffers/go:v1.31.0
     out: .
     opt: paths=source_relative
-  - plugin: buf.build/grpc-ecosystem/gateway:v2.18.0
+  - remote: buf.build/grpc-ecosystem/gateway:v2.18.0
     out: .
     opt: paths=source_relative
-  - plugin: buf.build/grpc-ecosystem/openapiv2:v2.18.0
+  - remote: buf.build/grpc-ecosystem/openapiv2:v2.18.0
     out: .
-  - plugin: buf.build/grpc/go:v1.3.0
+  - remote: buf.build/grpc/go:v1.3.0
     out: .
     opt:
       - paths=source_relative

example/bookstore/v1/bookstore.pb.go

@@ -69,7 +69,7 @@ service Bookstore {
     };
   }
 
-  // archive a book.
+  // archive abook.
   rpc archiveBook ( ArchiveBookRequest ) returns ( aep.api.Operation ) {
     option (google.api.http) = {
       post: "/{path=publishers/*/books/*}:archive",

example/bookstore/v1/bookstore.proto

@@ -7,19 +7,64 @@ import (
 	"log"
 	"log/slog"
 	"net"
+	"sync"
+	"time"
 
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 
+	_ "buf.build/gen/go/aep/api/protocolbuffers/go/aep/api"
+	api "buf.build/gen/go/aep/api/protocolbuffers/go/aep/api"
+	lrpb "cloud.google.com/go/longrunning/autogen/longrunningpb"
 	bpb "github.com/aep-dev/aepc/example/bookstore/v1"
 	_ "github.com/mattn/go-sqlite3" // sqlite3 driver
 	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/types/known/anypb"
 	"google.golang.org/protobuf/types/known/emptypb"
 )
 
+type operationStatus struct {
+	Done   bool
+	Result interface{}
+	Error  error
+}
+
+type operationStore struct {
+	mu         sync.Mutex
+	operations map[string]*operationStatus
+}
+
+var opStore = &operationStore{
+	operations: make(map[string]*operationStatus),
+}
+
+func (s *operationStore) createOperation(id string) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.operations[id] = &operationStatus{Done: false}
+}
+
+func (s *operationStore) completeOperation(id string, result interface{}, err error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if op, exists := s.operations[id]; exists {
+		op.Done = true
+		op.Result = result
+		op.Error = err
+	}
+}
+
+func (s *operationStore) getOperation(id string) (*operationStatus, bool) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	op, exists := s.operations[id]
+	return op, exists
+}
+
 type BookstoreServer struct {
 	bpb.UnimplementedBookstoreServer
+	lrpb.UnimplementedOperationsServer
 	db *sql.DB
 }
 
@@ -166,6 +211,64 @@ func (s BookstoreServer) ListBooks(_ context.Context, r *bpb.ListBooksRequest) (
 	return &bpb.ListBooksResponse{Results: books}, nil
 }
 
+func (s BookstoreServer) ArchiveBook(ctx context.Context, r *bpb.ArchiveBookRequest) (*api.Operation, error) {
+	log.Printf("archiving book %q", r.Path)
+
+	operationID := fmt.Sprintf("op-%d", time.Now().UnixNano())
+	opStore.createOperation(operationID)
+
+	go func() {
+		// Simulate the archiving process
+		result, err := s.db.Exec(`
+			UPDATE books
+			SET published = false
+			WHERE path = ?`,
+			r.Path)
+		if err != nil {
+			opStore.completeOperation(operationID, nil, status.Errorf(codes.Internal, "failed to archive book: %v", err))
+			return
+		}
+
+		rows, err := result.RowsAffected()
+		if err != nil {
+			opStore.completeOperation(operationID, nil, status.Errorf(codes.Internal, "failed to get rows affected: %v", err))
+			return
+		}
+		if rows == 0 {
+			opStore.completeOperation(operationID, nil, status.Errorf(codes.NotFound, "book %q not found", r.Path))
+			return
+		}
+
+		opStore.completeOperation(operationID, &emptypb.Empty{}, nil)
+	}()
+
+	return &api.Operation{Path: operationID, Done: false}, nil
+}
+
+func (s BookstoreServer) GetOperation(ctx context.Context, r *lrpb.GetOperationRequest) (*lrpb.Operation, error) {
+	op, exists := opStore.getOperation(r.Name)
+	if !exists {
+		return nil, status.Errorf(codes.NotFound, "operation %q not found", r.Name)
+	}
+
+	operation := &lrpb.Operation{
+		Name: r.Name,
+		Done: op.Done,
+	}
+
+	if op.Error != nil {
+		operation.Result = &lrpb.Operation_Error{
+			Error: status.Convert(op.Error).Proto(),
+		}
+	} else {
+		operation.Result = &lrpb.Operation_Response{
+			Response: op.Result.(*anypb.Any),
+		}
+	}
+
+	return operation, nil
+}
+
 func (s BookstoreServer) CreatePublisher(_ context.Context, r *bpb.CreatePublisherRequest) (*bpb.Publisher, error) {
 	publisher := proto.Clone(r.Publisher).(*bpb.Publisher)
 	log.Printf("creating publisher %q", r)

example/bookstore/v1/bookstore_grpc.pb.go

@@ -0,0 +1,87 @@
+package service
+
+import (
+	"context"
+	"database/sql"
+	"testing"
+	"time"
+
+	lrpb "cloud.google.com/go/longrunning/autogen/longrunningpb"
+	bpb "github.com/aep-dev/aepc/example/bookstore/v1"
+	_ "github.com/mattn/go-sqlite3"
+)
+
+func setupTestDB(t *testing.T) *sql.DB {
+	db, err := sql.Open("sqlite3", ":memory:")
+	if err != nil {
+		t.Fatalf("failed to open test database: %v", err)
+	}
+
+	_, err = db.Exec(`
+		CREATE TABLE books (
+			path TEXT PRIMARY KEY,
+			author TEXT,
+			price REAL,
+			published BOOLEAN,
+			edition INTEGER,
+			isbn TEXT
+		);
+	`)
+	if err != nil {
+		t.Fatalf("failed to create test table: %v", err)
+	}
+
+	return db
+}
+
+func TestArchiveBookOperation(t *testing.T) {
+	db := setupTestDB(t)
+	defer db.Close()
+
+	s := NewBookstoreServer(db)
+
+	// Insert a test book
+	_, err := db.Exec(`
+		INSERT INTO books (path, author, price, published, edition, isbn)
+		VALUES (?, ?, ?, ?, ?, ?)
+	`, "publishers/1/books/1", "Author Name", 19.99, true, 1, "1234567890")
+	if err != nil {
+		t.Fatalf("failed to insert test book: %v", err)
+	}
+
+	// Archive the book
+	r := &bpb.ArchiveBookRequest{Path: "publishers/1/books/1"}
+	operation, err := s.ArchiveBook(context.Background(), r)
+	if err != nil {
+		t.Fatalf("ArchiveBook failed: %v", err)
+	}
+
+	if operation.Done {
+		t.Fatalf("expected operation to not be done immediately, got true")
+	}
+
+	// Simulate waiting for the operation to complete
+	time.Sleep(100 * time.Millisecond)
+
+	// Check operation status
+	getOpReq := &lrpb.GetOperationRequest{Name: operation.Path}
+	opResp, err := s.GetOperation(context.Background(), getOpReq)
+	if err != nil {
+		t.Fatalf("GetOperation failed: %v", err)
+	}
+
+	if !opResp.Done {
+		t.Fatalf("expected operation to be done, got false")
+	}
+
+	// Verify the book is archived
+	var published bool
+	err = db.QueryRow("SELECT published FROM books WHERE path = ?", "publishers/1/books/1").Scan(&published)
+	if err != nil {
+		t.Fatalf("failed to query book: %v", err)
+	}
+
+	if published {
+		t.Fatalf("expected published to be false, got true")
+	}
+}