@nakedev/go-scaffold 0.1.2 → 0.1.4

package/templates/generate/module/minimal/handler.go.hbs

@@ -1,22 +1,46 @@
 package {{pkg}}
 
 import (
+{{#if auth}}
+	"{{goModule}}/internal/shared/middleware"
+
+{{/if}}
 	"github.com/gin-gonic/gin"
 )
 
+// service is intentionally empty until `generate method` adds the exact
+// application operations required by this HTTP adapter.
+type service interface {
+	// go-scaffold:service-interface
+}
+
 // Handler = delivery for {{pkg}} (parses HTTP, calls the service, attaches errors for the middleware to render)
 type Handler struct {
-	svc *Service
+	svc service
+{{#if auth}}
+	jwtSecret string
+{{/if}}
+{{#if permission}}
+	authz *middleware.Authz
+{{/if}}
 }
 
-func NewHandler(svc *Service) *Handler {
-	return &Handler{svc: svc}
+func NewHandler(svc service{{#if auth}}, jwtSecret string{{/if}}{{#if permission}}, authz *middleware.Authz{{/if}}) *Handler {
+	return &Handler{
+		svc: svc,
+{{#if auth}}
+		jwtSecret: jwtSecret,
+{{/if}}
+{{#if permission}}
+		authz: authz,
+{{/if}}
+	}
 }
 
 // Register wires {{pkg}}'s routes onto the router group (takes an IRouter so it can be nested under /v1)
 // minimal module: no routes yet — add them with `go-scaffold generate method {{pkg}} <name> --type ...`
 func (h *Handler) Register(rg gin.IRouter) {
-	g := rg.Group("/{{plural}}")
+	g := rg.Group("/{{plural}}"{{#if auth}}, middleware.RequireAuth(h.jwtSecret){{/if}}{{#if permission}}, h.authz.Require("{{permission}}"){{/if}})
 	_ = g
 	// go-scaffold:handler-routes
 }

package/templates/generate/module/minimal/handler_test.go.hbs

@@ -1,70 +1,10 @@
 package {{pkg}}
 
-import (
-	"bytes"
-	"net/http/httptest"
-	"os"
-	"sync"
-	"testing"
-
-	"{{goModule}}/internal/app/{{modulePath}}/model"
-	"{{goModule}}/internal/shared/middleware"
-
-	"gorm.io/gorm"
-
-	"github.com/gin-gonic/gin"
-	"gorm.io/driver/postgres"
-)
-
-// integration test harness, backed by real Postgres (same engine as prod, no sqlite) — skips if
-// the DB isn't reachable. minimal module: no routes yet, so no tests reference this yet — kept
-// ready for once `generate method` adds endpoints (start the DB: docker compose up -d, override
-// with TEST_DB_DSN)
-//nolint:unused
-var (
-	testDBOnce sync.Once
-	testDB     *gorm.DB
-	testDBErr  error
-)
-
-//nolint:unused
-func dbForTest(t *testing.T) *gorm.DB {
-	t.Helper()
-	testDBOnce.Do(func() {
-		dsn := os.Getenv("TEST_DB_DSN")
-		if dsn == "" {
-			dsn = "postgres://postgres:postgres@localhost:5432/{{dbName}}?sslmode=disable"
-		}
-		if testDB, testDBErr = gorm.Open(postgres.Open(dsn), &gorm.Config{TranslateError: true}); testDBErr == nil {
-			_ = testDB.Migrator().DropTable(&model.{{pascalName}}{})
-			testDBErr = testDB.AutoMigrate(&model.{{pascalName}}{})
-		}
-	})
-	if testDBErr != nil {
-		t.Skipf("postgres not ready (docker compose up -d, or set TEST_DB_DSN): %v", testDBErr)
-	}
-	return testDB
-}
-
-// setup builds the full stack on a transaction that's rolled back at the end → each test is isolated, no leftover rows
+// serviceStub embeds the concrete service so a generated method automatically
+// satisfies the handler's narrow service interface. Add explicit function-backed
+// overrides here when writing focused handler tests for that method.
 //
 //nolint:unused
-func setup(t *testing.T) *gin.Engine {
-	t.Helper()
-	gin.SetMode(gin.TestMode)
-	tx := dbForTest(t).Begin()
-	t.Cleanup(func() { tx.Rollback() })
-	r := gin.New()
-	r.Use(middleware.RequestID(), middleware.Error())
-	NewHandler(NewService(NewRepository(tx))).Register(r)
-	return r
-}
-
-//nolint:unused
-func do(r *gin.Engine, method, path, body string) *httptest.ResponseRecorder {
-	req := httptest.NewRequest(method, path, bytes.NewBufferString(body))
-	req.Header.Set("Content-Type", "application/json")
-	w := httptest.NewRecorder()
-	r.ServeHTTP(w, req)
-	return w
+type serviceStub struct {
+	*Service
 }

package/templates/generate/module/minimal/service_test.go.hbs

@@ -11,37 +11,60 @@ import (
 	"github.com/google/uuid"
 )
 
-// fakeRepo = mock of the repository interface, so the service can be tested without a DB
-// minimal module: no service methods yet, so no tests reference this — kept ready for
-// when `generate method` adds one (its patches append matching stubs here automatically
-// for a `get --get-mode one --field` lookup)
+// repositoryStub is ready for focused use-case tests added alongside generated
+// methods. Every unset dependency panics so unexpected orchestration is visible.
+//
 //nolint:unused
-type fakeRepo struct {
-	err error
-	m   *model.{{pascalName}}
+type repositoryStub struct {
+	createFn   func(context.Context, *model.{{pascalName}}) error
+	findAllFn  func(context.Context, int, int) ([]model.{{pascalName}}, error)
+	findByIDFn func(context.Context, uuid.UUID) (*model.{{pascalName}}, error)
+	updateFn   func(context.Context, *model.{{pascalName}}) error
+	deleteFn   func(context.Context, uuid.UUID) error
+	// go-scaffold:repository-stub-fields
 }
 
 //nolint:unused
-func (f *fakeRepo) Create(context.Context, *model.{{pascalName}}) error                    { return f.err }
+func (s *repositoryStub) Create(ctx context.Context, m *model.{{pascalName}}) error {
+	if s.createFn == nil {
+		panic("unexpected repository.Create call")
+	}
+	return s.createFn(ctx, m)
+}
 
 //nolint:unused
-func (f *fakeRepo) FindAll(context.Context, int, int) ([]model.{{pascalName}}, error) { return nil, f.err }
+func (s *repositoryStub) FindAll(ctx context.Context, limit, offset int) ([]model.{{pascalName}}, error) {
+	if s.findAllFn == nil {
+		panic("unexpected repository.FindAll call")
+	}
+	return s.findAllFn(ctx, limit, offset)
+}
 
 //nolint:unused
-func (f *fakeRepo) FindByID(context.Context, uuid.UUID) (*model.{{pascalName}}, error) {
-	if f.err != nil {
-		return nil, f.err
+func (s *repositoryStub) FindByID(ctx context.Context, id uuid.UUID) (*model.{{pascalName}}, error) {
+	if s.findByIDFn == nil {
+		panic("unexpected repository.FindByID call")
 	}
-	return f.m, nil
+	return s.findByIDFn(ctx, id)
 }
 
 //nolint:unused
-func (f *fakeRepo) Update(context.Context, *model.{{pascalName}}) error { return f.err }
+func (s *repositoryStub) Update(ctx context.Context, m *model.{{pascalName}}) error {
+	if s.updateFn == nil {
+		panic("unexpected repository.Update call")
+	}
+	return s.updateFn(ctx, m)
+}
 
 //nolint:unused
-func (f *fakeRepo) Delete(context.Context, uuid.UUID) error { return f.err }
+func (s *repositoryStub) Delete(ctx context.Context, id uuid.UUID) error {
+	if s.deleteFn == nil {
+		panic("unexpected repository.Delete call")
+	}
+	return s.deleteFn(ctx, id)
+}
 
-// go-scaffold:fake-repo-methods
+// go-scaffold:repository-stub-methods
 
 //nolint:unused
 func status(t *testing.T, err error) int {

package/templates/generate/module/model/model.go.hbs

@@ -18,3 +18,10 @@ type {{pascalName}} struct {
 	CreatedAt time.Time `json:"created_at"`
 	UpdatedAt time.Time `json:"updated_at"`
 }
+
+// TableName pins the persistence contract to the versioned SQL migrations.
+// Do not rely on GORM's English inflector: irregular/plural module names must
+// resolve to exactly the same table in development and production.
+func ({{pascalName}}) TableName() string {
+	return "{{tableName}}"
+}

package/templates/generate/module/permission.down.sql.hbs

@@ -0,0 +1,5 @@
+-- intentionally not deleting the permission row: another module generated
+-- later may have reused this same code (the up migration's ON CONFLICT
+-- assumes exactly that), and this file can't know whether that happened.
+-- An unused permission row with no route checking it is harmless — delete
+-- it by hand if you're sure nothing else references '{{permission}}'.

package/templates/generate/module/permission.up.sql.hbs

@@ -0,0 +1,4 @@
+-- ON CONFLICT DO NOTHING: safe to re-generate a module reusing a permission
+-- code another module already inserted (e.g. a shared "orders:manage").
+INSERT INTO permissions (code, description) VALUES ('{{permission}}', 'Manage {{plural}}')
+ON CONFLICT (code) DO NOTHING;

package/templates/generate/module/repository_test.go.hbs

@@ -0,0 +1,79 @@
+package {{pkg}}
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"{{goModule}}/internal/app/{{modulePath}}/model"
+
+	"github.com/google/uuid"
+	"gorm.io/driver/postgres"
+	"gorm.io/gorm"
+)
+
+// repositoryDBForTest expects the test database schema to come from the same
+// versioned SQL migrations used in production. Unit tests stay database-free;
+// CI sets REQUIRE_TEST_DB=true so an unavailable/unmigrated database fails
+// instead of becoming a false-green skip.
+func repositoryDBForTest(t *testing.T) *gorm.DB {
+	t.Helper()
+	dsn := os.Getenv("TEST_DB_DSN")
+	if dsn == "" {
+		if os.Getenv("REQUIRE_TEST_DB") == "true" {
+			t.Fatal("TEST_DB_DSN is required when REQUIRE_TEST_DB=true")
+		}
+		t.Skip("repository integration test skipped: set TEST_DB_DSN to a migrated PostgreSQL database")
+	}
+
+	db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{TranslateError: true})
+	if err != nil {
+		if os.Getenv("REQUIRE_TEST_DB") == "true" {
+			t.Fatalf("open required test database: %v", err)
+		}
+		t.Skipf("repository integration test skipped: %v", err)
+	}
+
+	sqlDB, err := db.DB()
+	if err != nil {
+		t.Fatalf("get SQL database handle: %v", err)
+	}
+	if err := sqlDB.Ping(); err != nil {
+		if os.Getenv("REQUIRE_TEST_DB") == "true" {
+			t.Fatalf("ping required test database: %v", err)
+		}
+		t.Skipf("repository integration test skipped: %v", err)
+	}
+
+	tx := db.Begin()
+	if tx.Error != nil {
+		t.Fatalf("begin test transaction: %v", tx.Error)
+	}
+	t.Cleanup(func() {
+		if err := tx.Rollback().Error; err != nil {
+			t.Errorf("rollback test transaction: %v", err)
+		}
+	})
+	return tx
+}
+
+func TestRepository_CreateFindDelete(t *testing.T) {
+	repo := NewRepository(repositoryDBForTest(t))
+	ctx := context.Background()
+	id := uuid.New()
+	item := &model.{{pascalName}}{ID: id}
+
+	if err := repo.Create(ctx, item); err != nil {
+		t.Fatalf("create: %v", err)
+	}
+	found, err := repo.FindByID(ctx, id)
+	if err != nil {
+		t.Fatalf("find by id: %v", err)
+	}
+	if found.ID != id {
+		t.Fatalf("want id %s, got %s", id, found.ID)
+	}
+	if err := repo.Delete(ctx, id); err != nil {
+		t.Fatalf("delete: %v", err)
+	}
+}

package/templates/generate/module/service.go.hbs

@@ -33,8 +33,9 @@ func NewService(repo repository) *Service {
 	return &Service{repo: repo}
 }
 
-func (s *Service) Create(ctx context.Context) (*model.{{pascalName}}, error) {
-	// TODO: accept and set real fields from createInput
+func (s *Service) Create(ctx context.Context, in createInput) (*model.{{pascalName}}, error) {
+	// TODO: set real fields from in
+	_ = in
 	m := &model.{{pascalName}}{ID: id.New()}
 	if err := s.repo.Create(ctx, m); err != nil {
 		if dberr.IsDuplicate(err) {
@@ -61,12 +62,13 @@ func (s *Service) Get(ctx context.Context, id uuid.UUID) (*model.{{pascalName}},
 	return m, nil
 }
 
-func (s *Service) Update(ctx context.Context, id uuid.UUID) (*model.{{pascalName}}, error) {
+func (s *Service) Update(ctx context.Context, id uuid.UUID, in updateInput) (*model.{{pascalName}}, error) {
 	m, err := s.repo.FindByID(ctx, id)
 	if err != nil {
 		return nil, wrapFindErr(err)
 	}
-	// TODO: apply real fields from updateInput before saving
+	// TODO: apply real fields from in before saving
+	_ = in
 	if err := s.repo.Update(ctx, m); err != nil {
 		if dberr.IsDuplicate(err) {
 			return nil, errConflict()

package/templates/generate/module/service_test.go.hbs

@@ -12,24 +12,54 @@ import (
 	"gorm.io/gorm"
 )
 
-// fakeRepo = mock of the repository interface, so the service can be tested without a DB
-type fakeRepo struct {
-	err error
-	m   *model.{{pascalName}}
+// repositoryStub exposes one function per dependency operation. Tests configure
+// only the calls they expect; an unexpected call panics instead of silently
+// returning a shared zero value/error that can hide broken orchestration.
+type repositoryStub struct {
+	createFn   func(context.Context, *model.{{pascalName}}) error
+	findAllFn  func(context.Context, int, int) ([]model.{{pascalName}}, error)
+	findByIDFn func(context.Context, uuid.UUID) (*model.{{pascalName}}, error)
+	updateFn   func(context.Context, *model.{{pascalName}}) error
+	deleteFn   func(context.Context, uuid.UUID) error
+	// go-scaffold:repository-stub-fields
 }
 
-func (f *fakeRepo) Create(context.Context, *model.{{pascalName}}) error                    { return f.err }
-func (f *fakeRepo) FindAll(context.Context, int, int) ([]model.{{pascalName}}, error) { return nil, f.err }
-func (f *fakeRepo) FindByID(context.Context, uuid.UUID) (*model.{{pascalName}}, error) {
-	if f.err != nil {
-		return nil, f.err
+func (s *repositoryStub) Create(ctx context.Context, m *model.{{pascalName}}) error {
+	if s.createFn == nil {
+		panic("unexpected repository.Create call")
 	}
-	return f.m, nil
+	return s.createFn(ctx, m)
 }
-func (f *fakeRepo) Update(context.Context, *model.{{pascalName}}) error { return f.err }
-func (f *fakeRepo) Delete(context.Context, uuid.UUID) error             { return f.err }
 
-// go-scaffold:fake-repo-methods
+func (s *repositoryStub) FindAll(ctx context.Context, limit, offset int) ([]model.{{pascalName}}, error) {
+	if s.findAllFn == nil {
+		panic("unexpected repository.FindAll call")
+	}
+	return s.findAllFn(ctx, limit, offset)
+}
+
+func (s *repositoryStub) FindByID(ctx context.Context, id uuid.UUID) (*model.{{pascalName}}, error) {
+	if s.findByIDFn == nil {
+		panic("unexpected repository.FindByID call")
+	}
+	return s.findByIDFn(ctx, id)
+}
+
+func (s *repositoryStub) Update(ctx context.Context, m *model.{{pascalName}}) error {
+	if s.updateFn == nil {
+		panic("unexpected repository.Update call")
+	}
+	return s.updateFn(ctx, m)
+}
+
+func (s *repositoryStub) Delete(ctx context.Context, id uuid.UUID) error {
+	if s.deleteFn == nil {
+		panic("unexpected repository.Delete call")
+	}
+	return s.deleteFn(ctx, id)
+}
+
+// go-scaffold:repository-stub-methods
 
 func status(t *testing.T, err error) int {
 	t.Helper()
@@ -41,24 +71,45 @@ func status(t *testing.T, err error) int {
 }
 
 func TestService_Create_Duplicate(t *testing.T) {
-	svc := NewService(&fakeRepo{err: gorm.ErrDuplicatedKey})
-	_, err := svc.Create(context.Background())
+	repo := &repositoryStub{
+		createFn: func(context.Context, *model.{{pascalName}}) error {
+			return gorm.ErrDuplicatedKey
+		},
+	}
+	svc := NewService(repo)
+
+	_, err := svc.Create(context.Background(), createInput{})
+
 	if got := status(t, err); got != 409 {
 		t.Fatalf("want 409 conflict, got %d", got)
 	}
 }
 
 func TestService_Get_NotFound(t *testing.T) {
-	svc := NewService(&fakeRepo{err: gorm.ErrRecordNotFound})
+	repo := &repositoryStub{
+		findByIDFn: func(context.Context, uuid.UUID) (*model.{{pascalName}}, error) {
+			return nil, gorm.ErrRecordNotFound
+		},
+	}
+	svc := NewService(repo)
+
 	_, err := svc.Get(context.Background(), uuid.New())
+
 	if got := status(t, err); got != 404 {
 		t.Fatalf("want 404, got %d", got)
 	}
 }
 
 func TestService_List_DBError_Becomes500(t *testing.T) {
-	svc := NewService(&fakeRepo{err: errors.New("connection refused")})
+	repo := &repositoryStub{
+		findAllFn: func(context.Context, int, int) ([]model.{{pascalName}}, error) {
+			return nil, errors.New("connection refused")
+		},
+	}
+	svc := NewService(repo)
+
 	_, err := svc.List(context.Background(), 20, 0)
+
 	if got := status(t, err); got != 500 {
 		t.Fatalf("want 500, got %d", got)
 	}

package/tests/integration/default-module.test.mjs

@@ -0,0 +1,46 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const ROOT = path.dirname(path.dirname(path.dirname(fileURLToPath(import.meta.url))));
+const CLI = path.join(ROOT, "bin", "go-scaffold.js");
+
+function runCLI(cwd, ...args) {
+  return execFileSync("node", [CLI, ...args], {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+}
+
+test("generate module defaults to a safe minimal module", () => {
+  const scratch = mkdtempSync(path.join(tmpdir(), "go-scaffold-default-module-"));
+  try {
+    runCLI(scratch, "create", "sample", "--defaults", "--no-docker");
+    const project = path.join(scratch, "sample");
+
+    const output = runCLI(project, "generate", "module", "orders");
+    const handler = readFileSync(
+      path.join(project, "internal", "app", "order", "handler.go"),
+      "utf8"
+    );
+
+    assert.match(output, /registered empty route group/);
+    assert.doesNotMatch(handler, /g\.POST\(/);
+    assert.equal(existsSync(path.join(project, "docs", "orders")), false);
+
+    const legacyOutput = runCLI(project, "generate", "module", "widgets", "--no-full");
+    const legacyHandler = readFileSync(
+      path.join(project, "internal", "app", "widget", "handler.go"),
+      "utf8"
+    );
+    assert.match(legacyOutput, /registered empty route group/);
+    assert.doesNotMatch(legacyHandler, /g\.POST\(/);
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+});

package/tests/integration/generator-naming.test.mjs

@@ -0,0 +1,81 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import {
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const ROOT = path.dirname(path.dirname(path.dirname(fileURLToPath(import.meta.url))));
+const CLI = path.join(ROOT, "bin", "go-scaffold.js");
+
+function runCLI(cwd, ...args) {
+  return execFileSync("node", [CLI, ...args], {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+}
+
+function read(root, relativePath) {
+  return readFileSync(path.join(root, relativePath), "utf8");
+}
+
+function migration(root, suffix) {
+  const filename = readdirSync(path.join(root, "migrations")).find((entry) =>
+    entry.endsWith(suffix)
+  );
+  assert.ok(filename, `missing migration ending with ${suffix}`);
+  return read(root, path.join("migrations", filename));
+}
+
+test("plural module input produces a singular entity with one explicit table name", () => {
+  const scratch = mkdtempSync(path.join(tmpdir(), "go-scaffold-naming-"));
+  try {
+    runCLI(scratch, "create", "sample", "--defaults", "--no-docker");
+    const project = path.join(scratch, "sample");
+    runCLI(project, "generate", "module", "orders");
+
+    const model = read(project, "internal/app/order/model/model.go");
+    assert.match(model, /type Order struct/);
+    assert.match(
+      model,
+      /func \(Order\) TableName\(\) string \{\s*return "orders"\s*\}/
+    );
+    assert.match(migration(project, "_create_orders.up.sql"), /CREATE TABLE orders/);
+    assert.match(read(project, "internal/app/order/handler.go"), /Group\("\/orders"/);
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+});
+
+test("multi-word module keeps URL words and uses snake_case SQL identifiers", () => {
+  const scratch = mkdtempSync(path.join(tmpdir(), "go-scaffold-multiword-"));
+  try {
+    runCLI(scratch, "create", "sample", "--defaults", "--no-docker");
+    const project = path.join(scratch, "sample");
+    runCLI(project, "generate", "module", "order-items");
+
+    const model = read(project, "internal/app/orderitem/model/model.go");
+    assert.match(model, /type OrderItem struct/);
+    assert.match(
+      model,
+      /func \(OrderItem\) TableName\(\) string \{\s*return "order_items"\s*\}/
+    );
+    assert.match(
+      migration(project, "_create_order-items.up.sql"),
+      /CREATE TABLE order_items/
+    );
+    assert.match(
+      read(project, "internal/app/orderitem/handler.go"),
+      /Group\("\/order-items"/
+    );
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+});

package/tests/integration/generator-unit-test-seams.test.mjs

@@ -0,0 +1,91 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const ROOT = path.dirname(path.dirname(path.dirname(fileURLToPath(import.meta.url))));
+const CLI = path.join(ROOT, "bin", "go-scaffold.js");
+
+function run(command, args, cwd) {
+  return execFileSync(command, args, {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+}
+
+function read(project, relativePath) {
+  return readFileSync(path.join(project, relativePath), "utf8");
+}
+
+test("generated modules have scalable service and handler unit-test seams", () => {
+  const scratch = mkdtempSync(path.join(tmpdir(), "go-scaffold-unit-seams-"));
+  try {
+    run("node", [CLI, "create", "sample", "--defaults", "--no-docker"], scratch);
+    const project = path.join(scratch, "sample");
+    run("node", [CLI, "generate", "module", "orders", "--full"], project);
+
+    const handler = read(project, "internal/app/order/handler.go");
+    assert.match(handler, /type service interface \{/);
+    assert.match(handler, /svc service/);
+    assert.doesNotMatch(handler, /svc \*Service/);
+    assert.match(handler, /Create\(context\.Context, createInput\)/);
+    assert.match(handler, /Update\(context\.Context, uuid\.UUID, updateInput\)/);
+
+    const service = read(project, "internal/app/order/service.go");
+    assert.match(service, /Create\(ctx context\.Context, in createInput\)/);
+    assert.match(service, /Update\(ctx context\.Context, id uuid\.UUID, in updateInput\)/);
+
+    const serviceTest = read(project, "internal/app/order/service_test.go");
+    assert.match(serviceTest, /type repositoryStub struct/);
+    assert.match(serviceTest, /createFn\s+func/);
+    assert.match(serviceTest, /findByIDFn\s+func/);
+    assert.match(serviceTest, /updateFn\s+func/);
+    assert.doesNotMatch(serviceTest, /type fakeRepo struct/);
+
+    const handlerTest = read(project, "internal/app/order/handler_test.go");
+    assert.match(handlerTest, /type serviceStub struct/);
+    assert.match(handlerTest, /createFn\s+func/);
+    assert.doesNotMatch(handlerTest, /gorm\.io\/driver\/postgres/);
+    assert.doesNotMatch(handlerTest, /TEST_DB_DSN/);
+
+    const repositoryTest = read(project, "internal/app/order/repository_test.go");
+    assert.match(repositoryTest, /REQUIRE_TEST_DB/);
+    assert.match(repositoryTest, /TEST_DB_DSN/);
+    assert.doesNotMatch(repositoryTest, /AutoMigrate/);
+    assert.doesNotMatch(repositoryTest, /DropTable/);
+
+    const ci = read(project, ".github/workflows/ci.yml");
+    assert.match(ci, /migrate -path migrations/);
+    assert.match(ci, /REQUIRE_TEST_DB: "true"/);
+    assert.match(ci, /TEST_DB_DSN:/);
+
+    const itemDocs = read(project, "docs/orders/item.yaml");
+    const deleteContract = itemDocs.slice(itemDocs.indexOf("delete:"));
+    assert.doesNotMatch(deleteContract, /"404"/);
+
+    run("node", [CLI, "generate", "method", "orders", "approve", "--type", "patch"], project);
+    const openapi = read(project, "docs/openapi.yaml");
+    assert.match(openapi, /\/v1\/orders\/\{id\}\/approve:/);
+    const approveDocs = read(project, "docs/orders/methods/approve.yaml");
+    assert.match(approveDocs, /^parameters:/);
+    assert.match(approveDocs, /^patch:/m);
+    assert.match(approveDocs, /operationId: approveOrder/);
+    assert.doesNotMatch(approveDocs, /requestBody:/);
+
+    run("node", [CLI, "generate", "method", "orders", "submit", "--type", "post"], project);
+    const submitDocs = read(project, "docs/orders/methods/submit.yaml");
+    assert.doesNotMatch(submitDocs, /^parameters:/);
+    assert.doesNotMatch(submitDocs, /in: path/);
+    assert.match(submitDocs, /^post:/m);
+    assert.match(submitDocs, /requestBody:/);
+
+    run("go", ["mod", "tidy"], project);
+    run("go", ["test", "./..."], project);
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+});