@voxgig/sdkgen 0.44.0 → 1.0.1

package/project/.sdk/src/cmp/go/TestDirect_go.ts

@@ -1,5 +1,8 @@
 
 import {
+  Model,
+  ModelEntity,
+  nom,
   depluralize,
 } from '@voxgig/apidef'
 
@@ -8,6 +11,7 @@ import {
   File,
   cmp,
   snakify,
+  isAuthActive,
 } from '@voxgig/sdkgen'
 
 
@@ -55,13 +59,21 @@ function normalizePathParams(
 
 const TestDirect = cmp(function TestDirect(props: any) {
   const ctx$ = props.ctx$
-  const model = ctx$.model
+  const model: Model = ctx$.model
 
   const target = props.target
-  const entity = props.entity
+  const entity: ModelEntity = props.entity
   const gomodule = props.gomodule
 
-  const PROJECTNAME = model.Name.toUpperCase().replace(/[^A-Z_]/g, '_')
+  const PROJECTNAME = nom(model, 'Name').toUpperCase().replace(/[^A-Z_]/g, '_')
+
+  const authActive = isAuthActive(model)
+  const apikeyEnvEntry = authActive
+    ? `\n\t\t"${PROJECTNAME}_APIKEY":       "NONE",`
+    : ''
+  const apikeyLiveField = authActive
+    ? `\n\t\t\t"apikey": env["${PROJECTNAME}_APIKEY"],`
+    : ''
 
   const opnames = Object.keys(entity.op)
   const hasLoad = opnames.includes('load')
@@ -77,15 +89,64 @@ const TestDirect = cmp(function TestDirect(props: any) {
   // Get load point info
   const loadPoint = loadOp?.points?.[0]
   const loadPath = loadPoint ? normalizePathParams(loadPoint.parts || [], loadPoint?.args?.params || [], loadPoint?.rename?.param) : ''
-  const loadParams = loadPoint?.args?.params || []
+  const allLoadParams = loadPoint?.args?.params || []
+  // Some upstream OpenAPI specs declare a parameter as `in: path` even when
+  // that path has no `{name}` placeholder for it. Only path params that
+  // actually appear in the URL template should drive direct-test path-param
+  // setup and URL-substitution asserts; otherwise the SDK silently drops
+  // them and the URL-includes assert fails.
+  const _pathPlaceholders = new Set<string>()
+  for (const part of (loadPoint?.parts || [])) {
+    if (typeof part === 'string' && part.startsWith('{') && part.endsWith('}')) {
+      _pathPlaceholders.add(part.slice(1, -1))
+    }
+  }
+  const _renameMap = (loadPoint?.rename?.param || {}) as Record<string, string>
+  const _renamedPlaceholders = new Set<string>()
+  for (const ph of _pathPlaceholders) {
+    _renamedPlaceholders.add(ph)
+    for (const [orig, renamed] of Object.entries(_renameMap)) {
+      if (renamed === ph) _renamedPlaceholders.add(orig)
+    }
+  }
+  const loadParams = allLoadParams.filter((p: any) =>
+    _renamedPlaceholders.has(p.name) || _renamedPlaceholders.has(p.orig))
 
   // Get list point info
   const listPoint = listOp?.points?.[0]
   const listPath = listPoint ? normalizePathParams(listPoint.parts || [], listPoint?.args?.params || [], listPoint?.rename?.param) : ''
   const listParams = listPoint?.args?.params || []
 
+  // Required query params with spec-provided examples — needed in live mode
+  // to satisfy API contracts (e.g. /v2018/history requires city/start/end).
+  const loadQuery = loadPoint?.args?.query || []
+  const loadLiveQueryEntries = loadQuery
+    .filter((q: any) => q.reqd && undefined !== q.example && null !== q.example)
+  const loadLiveQueryLines = loadLiveQueryEntries
+    .map((q: any) => `\t\t\tquery["${q.name}"] = ${JSON.stringify(q.example)}`)
+    .join('\n')
+
+  const listQuery = listPoint?.args?.query || []
+  const listLiveQueryEntries = listQuery
+    .filter((q: any) => q.reqd && undefined !== q.example && null !== q.example)
+  const listLiveQueryLines = listLiveQueryEntries
+    .map((q: any) => `\t\t\tquery["${q.name}"] = ${JSON.stringify(q.example)}`)
+    .join('\n')
+
+  // Path params with spec-provided examples — when ALL load params have
+  // spec examples, prefer them over list-bootstrap. Spec example values are
+  // by definition real identifiers the API accepts (e.g. casa: "blue",
+  // fecha: "2024/01/01"), avoiding the brittle list-bootstrap path-param
+  // semantic mismatch.
+  const loadAllHaveExamples =
+    loadParams.length > 0 &&
+    loadParams.every((p: any) => undefined !== p.example && null !== p.example)
+  const loadExampleLines = loadAllHaveExamples
+    ? loadParams.map((p: any) => `\t\t\tparams["${p.name}"] = ${JSON.stringify(p.example)}`).join('\n')
+    : ''
+
   // Build the ENTID env var name for this entity
-  const entidEnvVar = `${PROJECTNAME}_TEST_${entity.Name.toUpperCase().replace(/[^A-Z_]/g, '_')}_ENTID`
+  const entidEnvVar = `${PROJECTNAME}_TEST_${nom(entity, 'NAME').replace(/[^A-Z_]/g, '_')}_ENTID`
 
   File({ name: entity.name + '_direct_test.' + target.ext }, () => {
 
@@ -119,12 +180,44 @@ func Test${entity.Name}Direct(t *testing.T) {
         return { name: p.name, key }
       })
 
+      // Track idmap keys this test consumes in live mode. If any are
+      // missing (no ENTID override), skip — the request would 4xx on
+      // undefined path params.
+      const listLiveIdKeys = listParams.length > 0
+        ? listLiveParams.map((lp: any) => lp.key)
+        : []
+      const listLiveIdKeysGoLiteral = listLiveIdKeys.length > 0
+        ? `[]string{${listLiveIdKeys.map((k: string) => `"${k}"`).join(', ')}}`
+        : ''
+      const listSkipBlock = listLiveIdKeys.length > 0
+        ? `		if setup.live {
+			for _, _liveKey := range ${listLiveIdKeysGoLiteral} {
+				if v := setup.idmap[_liveKey]; v == nil {
+					t.Skipf("live test needs %s via *_ENTID env var (synthetic IDs only)", _liveKey)
+					return
+				}
+			}
+		}
+`
+        : ''
+
       Content(`	t.Run("direct-list-${entity.name}", func(t *testing.T) {
 		setup := ${entity.name}DirectSetup([]any{
 			map[string]any{"id": "direct01"},
 			map[string]any{"id": "direct02"},
 		})
-		client := setup.client
+		_mode := "unit"
+		if setup.live {
+			_mode = "live"
+		}
+		if _shouldSkip, _reason := isControlSkipped("direct", "direct-list-${entity.name}", _mode); _shouldSkip {
+			if _reason == "" {
+				_reason = "skipped via sdk-test-control.json"
+			}
+			t.Skip(_reason)
+			return
+		}
+${listSkipBlock}		client := setup.client
 
 `)
 
@@ -160,15 +253,30 @@ func Test${entity.Name}Direct(t *testing.T) {
 `)
       }
 
-      Content(`		if err != nil {
-			t.Fatalf("direct failed: %v", err)
-		}
-
-		if result["ok"] != true {
-			t.Fatalf("expected ok to be true, got %v", result["ok"])
-		}
-		if core.ToInt(result["status"]) != 200 {
-			t.Fatalf("expected status 200, got %v", result["status"])
+      Content(`		if setup.live {
+			// Live mode is lenient: synthetic IDs frequently 4xx and the
+			// list-response shape varies wildly across public APIs. Skip
+			// rather than fail when the call doesn't return a usable list.
+			if err != nil {
+				t.Skipf("list call failed (likely synthetic IDs against live API): %v", err)
+			}
+			if result["ok"] != true {
+				t.Skipf("list call not ok (likely synthetic IDs against live API): %v", result)
+			}
+			status := core.ToInt(result["status"])
+			if status < 200 || status >= 300 {
+				t.Skipf("expected 2xx status, got %v", result["status"])
+			}
+		} else {
+			if err != nil {
+				t.Fatalf("direct failed: %v", err)
+			}
+			if result["ok"] != true {
+				t.Fatalf("expected ok to be true, got %v", result["ok"])
+			}
+			if core.ToInt(result["status"]) != 200 {
+				t.Fatalf("expected status 200, got %v", result["status"])
+			}
 		}
 
 		if !setup.live {
@@ -220,22 +328,75 @@ func Test${entity.Name}Direct(t *testing.T) {
       // Identify ancestor params (not 'id') for live mode
       const ancestorParams = loadParams.filter((p: any) => p.name !== 'id')
 
+      // Determine which idmap keys this load test will consume in live mode.
+      // - allHaveExamples: spec provides example values for every load
+      //   path-param, so live mode uses them — no idmap needed.
+      // - hasList: we list-bootstrap, so we need the keys for the list call's
+      //   path params (ancestors of the list path).
+      // - synthetic-only: we'd use idmap for load path-params; without an
+      //   override they're undefined and the live request 4xx's.
+      let loadLiveIdKeys: string[] = []
+      if (loadParams.length > 0 && !loadAllHaveExamples) {
+        if (hasList) {
+          loadLiveIdKeys = listParams.map((p: any) => {
+            return p.name === 'id'
+              ? entity.name + '01'
+              : p.name.replace(/_id$/, '') + '01'
+          })
+        } else {
+          loadLiveIdKeys = loadParams.map((p: any) => p.name + '01')
+        }
+      }
+      const loadSkipBlock = loadLiveIdKeys.length > 0
+        ? `		if setup.live {
+			for _, _liveKey := range []string{${loadLiveIdKeys.map(k => `"${k}"`).join(', ')}} {
+				if v := setup.idmap[_liveKey]; v == nil {
+					t.Skipf("live test needs %s via *_ENTID env var (synthetic IDs only)", _liveKey)
+					return
+				}
+			}
+		}
+`
+        : ''
+
       Content(`	t.Run("direct-load-${entity.name}", func(t *testing.T) {
 		setup := ${entity.name}DirectSetup(map[string]any{"id": "direct01"})
-		client := setup.client
+		_mode := "unit"
+		if setup.live {
+			_mode = "live"
+		}
+		if _shouldSkip, _reason := isControlSkipped("direct", "direct-load-${entity.name}", _mode); _shouldSkip {
+			if _reason == "" {
+				_reason = "skipped via sdk-test-control.json"
+			}
+			t.Skip(_reason)
+			return
+		}
+${loadSkipBlock}		client := setup.client
 
 `)
 
-      if (loadParams.length > 0) {
+      // Always emit a query map so the test can pass it to Direct(); only
+      // set values in live mode.
+      const needsQuery = loadParams.length > 0 || loadLiveQueryLines !== ''
+      if (needsQuery) {
         Content(`		params := map[string]any{}
+		query := map[string]any{}
 `)
 
         Content(`		if setup.live {
 `)
 
-        // In live mode: first list to get a real entity, then use its ID
-        if (hasList) {
-          // Build list params from idmap
+        // Required-query setup (e.g. /v2018/history needs city/start/end).
+        if (loadLiveQueryLines) {
+          Content(loadLiveQueryLines + '\n')
+        }
+
+        if (loadAllHaveExamples) {
+          // Use spec-provided path-param examples — no list bootstrap needed.
+          Content(loadExampleLines + '\n')
+        } else if (hasList && loadParams.length > 0) {
+          // List-bootstrap: first call list, take id from response.
           Content(`			listParams := map[string]any{}
 `)
           for (const p of listParams) {
@@ -252,10 +413,10 @@ func Test${entity.Name}Direct(t *testing.T) {
 				"params": listParams,
 			})
 			if listErr != nil {
-				t.Fatalf("list for load setup failed: %v", listErr)
+				t.Skipf("list call failed (likely synthetic IDs against live API): %v", listErr)
 			}
 			if listResult["ok"] != true {
-				t.Fatalf("list for load setup not ok: %v", listResult)
+				t.Skipf("list call not ok (likely synthetic IDs against live API): %v", listResult)
 			}
 
 			// Get first entity ID from list
@@ -274,11 +435,13 @@ func Test${entity.Name}Direct(t *testing.T) {
           }
         }
 
-        Content(`		} else {
+        if (loadParams.length > 0) {
+          Content(`		} else {
 `)
-        for (let i = 0; i < loadParams.length; i++) {
-          Content(`			params["${loadParams[i].name}"] = "direct0${i + 1}"
+          for (let i = 0; i < loadParams.length; i++) {
+            Content(`			params["${loadParams[i].name}"] = "direct0${i + 1}"
 `)
+          }
         }
         Content(`		}
 `)
@@ -291,24 +454,44 @@ func Test${entity.Name}Direct(t *testing.T) {
 `)
       if (loadParams.length > 0) {
         Content(`			"params": params,
+			"query":  query,
+`)
+      } else if (loadLiveQueryLines) {
+        Content(`			"params": params,
+			"query":  query,
 `)
       } else {
         Content(`			"params": map[string]any{},
 `)
       }
       Content(`		})
-		if err != nil {
-			t.Fatalf("direct failed: %v", err)
-		}
-
-		if result["ok"] != true {
-			t.Fatalf("expected ok to be true, got %v", result["ok"])
-		}
-		if core.ToInt(result["status"]) != 200 {
-			t.Fatalf("expected status 200, got %v", result["status"])
-		}
-		if result["data"] == nil {
-			t.Fatal("expected data to be non-nil")
+		if setup.live {
+			// Live mode is lenient: synthetic IDs frequently 4xx. Skip
+			// rather than fail when the load endpoint isn't reachable with
+			// the IDs we can construct from setup.idmap.
+			if err != nil {
+				t.Skipf("load call failed (likely synthetic IDs against live API): %v", err)
+			}
+			if result["ok"] != true {
+				t.Skipf("load call not ok (likely synthetic IDs against live API): %v", result)
+			}
+			status := core.ToInt(result["status"])
+			if status < 200 || status >= 300 {
+				t.Skipf("expected 2xx status, got %v", result["status"])
+			}
+		} else {
+			if err != nil {
+				t.Fatalf("direct failed: %v", err)
+			}
+			if result["ok"] != true {
+				t.Fatalf("expected ok to be true, got %v", result["ok"])
+			}
+			if core.ToInt(result["status"]) != 200 {
+				t.Fatalf("expected status 200, got %v", result["status"])
+			}
+			if result["data"] == nil {
+				t.Fatal("expected data to be non-nil")
+			}
 		}
 
 		if !setup.live {
@@ -360,15 +543,13 @@ func ${entity.name}DirectSetup(mockres any) *${entity.name}DirectSetupResult {
 
 	env := envOverride(map[string]any{
 		"${entidEnvVar}": map[string]any{},
-		"${PROJECTNAME}_TEST_LIVE":    "FALSE",
-		"${PROJECTNAME}_APIKEY":       "NONE",
+		"${PROJECTNAME}_TEST_LIVE":    "FALSE",${apikeyEnvEntry}
 	})
 
 	live := env["${PROJECTNAME}_TEST_LIVE"] == "TRUE"
 
 	if live {
-		mergedOpts := map[string]any{
-			"apikey": env["${PROJECTNAME}_APIKEY"],
+		mergedOpts := map[string]any{${apikeyLiveField}
 		}
 		client := sdk.New${model.const.Name}SDK(mergedOpts)