@voxgig/sdkgen 4.34.0 → 4.34.2

package/project/.sdk/tm/py/test/test_feature_corpus.py

@@ -30,7 +30,7 @@ _TEST_DIR = os.path.dirname(os.path.abspath(__file__))
 # without a listed feature still skips, not fails.
 def _corpus_feature_names():
     try:
-        with open(os.path.join(_TEST_DIR, "../../.sdk/test/test.json"), "r") as f:
+        with open(os.path.join(_TEST_DIR, "../../.sdk/test/test.json"), "r", encoding="utf-8") as f:
             return sorted((json.loads(f.read()).get("feature") or {}).keys())
     except OSError:
         return []
@@ -39,11 +39,11 @@ def _corpus_feature_names():
 FEATURE_CORPUS_NAMES = _corpus_feature_names()
 
 # The standard operation names, in the order the runner prefers them.
-FEATURE_CORPUS_OPS = ["load", "list", "create", "update", "remove"]
+FEATURE_CORPUS_OPS = ["load", "list", "create", "update", "patch", "remove"]
 
 
 def _load_corpus():
-    with open(os.path.join(_TEST_DIR, "../../.sdk/test/test.json"), "r") as f:
+    with open(os.path.join(_TEST_DIR, "../../.sdk/test/test.json"), "r", encoding="utf-8") as f:
         return json.loads(f.read())
 
 
@@ -252,6 +252,26 @@ def _record(client, name):
     return getattr(client, "_" + name, None)
 
 
+# The first feature a case composes that this SDK does not generate, probed
+# as a section's own feature is. Such a case is skipped rather than failed.
+def _missing_feature(kase, have):
+    spec = kase.get("feature")
+    if isinstance(spec, list):
+        names = [f.get("name") for f in spec if isinstance(f, dict)]
+    elif isinstance(spec, dict):
+        names = sorted(spec.keys())
+    else:
+        names = []
+    for name in names:
+        if not isinstance(name, str):
+            continue
+        if name not in have:
+            have[name] = _present(_client({"feature": [{"name": name, "active": True}]}), name)
+        if not have[name]:
+            return name
+    return None
+
+
 class TestFeatureCorpus:
 
     def test_corpus_carries_a_feature_section(self):
@@ -297,49 +317,66 @@ class TestFeatureCorpus:
         by_key = {o["key"]: o for o in ops}
 
         ran = 0
+        failed = []
+        have = {}
         for raw in cases:
             need = _tokens_used(raw)
             if need > len(ops):
+                print('skip "{}": needs {} operations, this SDK offers {}'.format(
+                    raw.get("name"), need, len(ops)))
+                continue
+
+            missing = _missing_feature(raw, have)
+            if missing is not None:
+                print('skip "{}": needs the {} feature, which this SDK does not generate'.format(
+                    raw.get("name"), missing))
                 continue
 
             tokens = {}
             for i in range(need):
                 tokens["#OP{}".format(i + 1)] = ops[i]["key"]
             kase = _resolve(raw, tokens)
-
-            client = _client(kase)
             label = kase.get("name")
-
-            for step in (kase.get("op") or []):
-                op = by_key.get(step["op"])
-                assert op is not None, "{}: no operation {}".format(label, step["op"])
-                ctrl = step.get("ctrl") or {}
-                wanterr = step.get("err")
-
-                try:
-                    _invoke(client, op, ctrl)
-                    assert wanterr is None, \
-                        "{}: {} was expected to fail, and did not".format(label, step["op"])
-                except AssertionError:
-                    raise
-                except Exception as err:
-                    assert wanterr is not None, \
-                        "{}: {} failed unexpectedly: {}".format(label, step["op"], err)
-                    if isinstance(wanterr, str):
-                        # The CODE, not the message: makeError prefixes and
-                        # humanises the text, so matching it would pass on any
-                        # error that happened to mention the word.
-                        code = getattr(err, "code", None)
-                        assert code == wanterr, \
-                            "{}: wrong error code: got {!r} ({}), want {!r}".format(
-                                label, code, err, wanterr)
-
-            _subset(_record(client, name), kase.get("out"), "{}: _{}".format(label, name))
             ran += 1
 
-        assert ran > 0, "every feature.{} case was skipped".format(name)
+            # Every failing case is reported, not only the first.
+            try:
+                client = _client(kase)
+
+                for step in (kase.get("op") or []):
+                    op = by_key.get(step["op"])
+                    assert op is not None, "{}: no operation {}".format(label, step["op"])
+                    ctrl = step.get("ctrl") or {}
+                    wanterr = step.get("err")
+
+                    try:
+                        _invoke(client, op, ctrl)
+                        assert wanterr is None, \
+                            "{}: {} was expected to fail, and did not".format(label, step["op"])
+                    except AssertionError:
+                        raise
+                    except Exception as err:
+                        assert wanterr is not None, \
+                            "{}: {} failed unexpectedly: {}".format(label, step["op"], err)
+                        if isinstance(wanterr, str):
+                            # The CODE, not the message: makeError prefixes and
+                            # humanises the text, so matching it would pass on any
+                            # error that happened to mention the word.
+                            code = getattr(err, "code", None)
+                            assert code == wanterr, \
+                                "{}: wrong error code: got {!r} ({}), want {!r}".format(
+                                    label, code, err, wanterr)
+
+                _subset(_record(client, name), kase.get("out"), "{}: _{}".format(label, name))
+            except Exception as err:
+                msg = str(err)
+                failed.append(msg if msg.startswith(str(label)) else "{}: {}".format(label, msg))
+
         # Say how many ran. A partial run is legitimate (an SDK with one
         # operation skips the cases needing two) but it should be visible
         # rather than inferred from a green tick.
         print("feature.{}: ran {} of {} case(s) against {} operation(s)".format(
             name, ran, len(cases), len(ops)))
+        assert ran > 0, "every feature.{} case was skipped".format(name)
+        assert not failed, "feature.{}: {} case(s) failed:\n  {}".format(
+            name, len(failed), "\n  ".join(failed))

package/project/.sdk/tm/py-data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) $$const.year$$ Voxgig
+Copyright (c) $$const.year$$ PROJECTPUBLISHER
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/project/.sdk/tm/py-data/Makefile

@@ -10,8 +10,8 @@ dev:
 test:
 	python3 -m pytest test/
 
-# Execute the generated quickstart notebook end to end. A quickstart that
-# does not run is a broken product, so this is part of `make test` in CI.
+# Execute the generated quickstart notebook end to end. `make test` does not
+# run it: that target runs pytest alone. This one needs jupyter installed.
 notebook:
 	python3 -m jupyter nbconvert --to notebook --execute \
 	  --stdout notebooks/quickstart.ipynb > /dev/null && echo "quickstart.ipynb OK"

package/project/.sdk/tm/rb/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) $$const.year$$ Voxgig
+Copyright (c) $$const.year$$ PROJECTPUBLISHER
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/project/.sdk/tm/rb/core/context.rb

@@ -10,6 +10,10 @@ require_relative 'error'
 require_relative 'helpers'
 
 class ProjectNameContext
+  # Every context of a client shares its root's operation cache. CRuby's GVL
+  # makes each Hash operation atomic; a Ruby without one needs this lock.
+  OPMAP_LOCK = Mutex.new
+
   attr_accessor :id, :out, :client, :utility, :ctrl, :meta, :config,
                 :entopts, :options, :entity, :shared, :opmap,
                 :data, :reqdata, :match, :reqmatch, :point,
@@ -83,12 +87,13 @@ class ProjectNameContext
     # served to every subsequent entity's call.
     entname = @entity&.respond_to?(:get_name) ? @entity.get_name : "_"
     cache_key = "#{entname}:#{opname}"
-    return @opmap[cache_key] if @opmap[cache_key]
+    cached = OPMAP_LOCK.synchronize { @opmap[cache_key] }
+    return cached if cached
     return ProjectNameOperation.new({}) if opname.empty?
 
     opcfg = VoxgigStruct.getpath(@config, "entity.#{entname}.op.#{opname}")
 
-    input = (opname == "update" || opname == "create") ? "data" : "match"
+    input = (opname == "update" || opname == "create" || opname == "patch") ? "data" : "match"
 
     points = []
     if opcfg.is_a?(Hash)
@@ -102,8 +107,8 @@ class ProjectNameContext
       "input" => input,
       "points" => points,
     })
-    @opmap[cache_key] = op
-    op
+    # Racing requests get the Operation stored first.
+    OPMAP_LOCK.synchronize { @opmap[cache_key] ||= op }
   end
 
   def make_error(code, msg)

package/project/.sdk/tm/rb/core/response.rb

@@ -3,7 +3,7 @@
 require_relative '../utility/struct/voxgig_struct'
 
 class ProjectNameResponse
-  attr_accessor :status, :status_text, :headers, :json_func, :body, :err
+  attr_accessor :status, :status_text, :headers, :json_func, :body, :err, :unreadable
 
   def initialize(resmap = {})
     resmap ||= {}
@@ -16,5 +16,7 @@ class ProjectNameResponse
     @json_func = jf.is_a?(Proc) ? jf : nil
     @body = VoxgigStruct.getprop(resmap, "body")
     @err = VoxgigStruct.getprop(resmap, "err")
+    # Set by a transport that could not read a non-blank body as JSON.
+    @unreadable = true == VoxgigStruct.getprop(resmap, "unreadable")
   end
 end

package/project/.sdk/tm/rb/core/spec.rb

@@ -2,7 +2,7 @@
 
 class ProjectNameSpec
   attr_accessor :parts, :headers, :alias_map, :base, :prefix, :suffix,
-                :params, :query, :step, :method, :body, :url, :path
+                :params, :query, :step, :method, :body, :url, :path, :authquery
 
   def initialize(specmap = {})
     specmap ||= {}
@@ -19,5 +19,8 @@ class ProjectNameSpec
     @body = specmap["body"] || specmap[:body]
     @url = specmap["url"] || specmap[:url] || ""
     @path = specmap["path"] || specmap[:path] || ""
+    # The query parameters prepare_auth placed: the credential, which the
+    # request sends and the entity's match leaves out.
+    @authquery = specmap["authquery"] || specmap[:authquery] || []
   end
 end

package/project/.sdk/tm/rb/feature/test_feature.rb

@@ -9,6 +9,25 @@ class ProjectNameTestFeature < ProjectNameBaseFeature
   # ops unwrap body.data.<field>, not just one level.
   ENVELOPE_RES_RE = /\A`body\.(.+)`\z/
 
+  # The key a list's response transform
+  # ["`$EACH`", "body", { "`$MERGE`" => "`.<key>`" }] reads each item's record under.
+  ITEM_ENVELOPE_RE = /\A`\.([^.`$]+)`\z/
+
+  def self.item_envelope_key(restf)
+    return nil unless restf.is_a?(Array) && 3 == restf.length &&
+      '`$EACH`' == restf[0] && 'body' == restf[1] && restf[2].is_a?(Hash)
+    merge = restf[2]['`$MERGE`']
+    m = merge.is_a?(String) ? ITEM_ENVELOPE_RE.match(merge) : nil
+    m.nil? ? nil : m[1]
+  end
+
+  # The record the mock keeps: the request data without `$body`, which only the
+  # wire carries.
+  def self.record(reqdata)
+    return reqdata unless reqdata.is_a?(Hash)
+    reqdata.reject { |k, _v| k == "$body" }
+  end
+
   def initialize
     super
     @version = "0.0.1"
@@ -28,12 +47,10 @@ class ProjectNameTestFeature < ProjectNameBaseFeature
     @client.mode = "test"
 
     # Ensure entity ids are correct.
-    VoxgigStruct.walk(entity) do |key, val, parent, path|
-      if path.length == 2 && val.is_a?(Hash) && key
-        val["id"] = key
-      end
+    VoxgigStruct.walk(entity, ->(key, val, _parent, path) {
+      val["id"] = key if path.length == 2 && val.is_a?(Hash) && key
       val
-    end
+    })
 
     test_self = self
 
@@ -51,6 +68,8 @@ class ProjectNameTestFeature < ProjectNameBaseFeature
         transform = point["transform"]
         next data unless transform.is_a?(Hash)
         restf = transform["res"]
+        key = ProjectNameTestFeature.item_envelope_key(restf)
+        next data.map { |item| { key => item } } if !key.nil? && data.is_a?(Array)
         next data unless restf.is_a?(String)
         m = ENVELOPE_RES_RE.match(restf)
         next data if m.nil?
@@ -106,7 +125,7 @@ class ProjectNameTestFeature < ProjectNameBaseFeature
         out = VoxgigStruct.clone(found)
         respond.call(200, out, nil)
 
-      elsif op.name == "update"
+      elsif op.name == "update" || op.name == "patch"
         # Match the existing entity by id only (or its alias). reqdata also
         # contains the new field values, which would otherwise cause select
         # to filter out the entity we want to update. When reqdata has no id,
@@ -130,7 +149,7 @@ class ProjectNameTestFeature < ProjectNameBaseFeature
         # update miss: 404, never another record
         return respond.call(404, nil, { "statusText" => "Not found" }) unless ent
         if ent.is_a?(Hash) && fctx.reqdata.is_a?(Hash)
-          VoxgigStruct.merge([ent, fctx.reqdata])
+          VoxgigStruct.merge([ent, ProjectNameTestFeature.record(fctx.reqdata)])
         end
         VoxgigStruct.delprop(ent, "$KEY")
         out = VoxgigStruct.clone(ent)
@@ -153,7 +172,7 @@ class ProjectNameTestFeature < ProjectNameBaseFeature
         id = fctx.utility.param.call(fctx, "id")
         id ||= "%04x%04x%04x%04x" % [rand(0x10000), rand(0x10000), rand(0x10000), rand(0x10000)]
 
-        ent = VoxgigStruct.clone(fctx.reqdata)
+        ent = VoxgigStruct.clone(ProjectNameTestFeature.record(fctx.reqdata))
         if ent.is_a?(Hash)
           ent["id"] = id
           entmap[id.to_s] = ent if id.is_a?(String)

package/project/.sdk/tm/rb/feature/validate_feature.rb

@@ -171,6 +171,8 @@ class ProjectNameValidateFeature < ProjectNameBaseFeature
     # fields will never name it - and under `strict` every custom-action call
     # would be rejected for the one key that made it reachable.
     out.delete("$action")
+    # Nor is `$body`, the raw request body.
+    out.delete("$body")
 
     out
   end
@@ -186,7 +188,7 @@ class ProjectNameValidateFeature < ProjectNameBaseFeature
   end
 
   def _entname(ctx)
-    name = ctx.entity.nil? ? nil : ctx.entity.name
+    name = ctx.entity.respond_to?(:get_name) ? ctx.entity.get_name : nil
     return name if name.is_a?(String) && !name.empty?
 
     entname = ctx.op.nil? ? nil : ctx.op.entity

package/project/.sdk/tm/rb/test/concurrency_test.rb

@@ -0,0 +1,160 @@
+# ProjectName SDK concurrency test
+#
+# Requests in flight at once on one client. Each resolves its operation
+# through the cache the client's root context shares with every request, and
+# registers and cleans secrets through the one registry the client holds.
+#
+# The interpreter switches threads about every 100ms, so each test runs long
+# enough to be switched in the middle of a resolution or a registration.
+
+require "minitest/autorun"
+require_relative "../ProjectName_sdk"
+
+class ConcurrencyTest < Minitest::Test
+  ROUNDS = 3
+  WIDTH = 8
+  OPS = 6000
+  SEEDED = 1000
+  ADDED = 400
+  MASKED = "a [redacted] b [redacted] c"
+
+  # Runs the block on WIDTH threads, released once every one is waiting, and
+  # returns what they raised.
+  def at_once
+    lock = Mutex.new
+    waiting = 0
+    ready = Queue.new
+    gate = Queue.new
+    seen = Queue.new
+    raised = Queue.new
+    threads = (0...WIDTH).map do |n|
+      Thread.new do
+        lock.synchronize { waiting += 1 }
+        ready << n
+        gate.pop
+        seen << lock.synchronize { waiting }
+        yield n
+      rescue Exception => e
+        raised << e
+      end
+    end
+    WIDTH.times { ready.pop }
+    WIDTH.times { gate << true }
+    threads.each(&:join)
+    released = Array.new(seen.size) { seen.pop }
+    assert_equal [WIDTH] * WIDTH, released, "threads released before #{WIDTH} were waiting"
+    Array.new(raised.size) { raised.pop }
+  end
+
+  def test_concurrent_resolutions_share_one_cached_operation
+    ROUNDS.times do |round|
+      client = ProjectNameSDK.test(nil, nil)
+      utility = client.get_utility
+      root = client.get_root_ctx
+      ops = Array.new(WIDTH) { Array.new(OPS) }
+
+      raised = at_once do |n|
+        OPS.times { |k| ops[n][k] = utility.make_context.call({ "opname" => "op#{k}" }, root).op }
+      end
+
+      assert_empty raised, "round #{round} raised: #{raised.inspect}"
+      OPS.times do |k|
+        cached = utility.make_context.call({ "opname" => "op#{k}" }, root).op
+        WIDTH.times do |n|
+          assert_same cached, ops[n][k], "round #{round}: op#{k} resolved to more than one Operation"
+        end
+      end
+    end
+  end
+
+  # A live client whose transport answers at once.
+  def live_client
+    ProjectNameSDK.new({
+      "base" => "http://concurrency.test/api",
+      "allow" => { "op" => "direct" },
+      "system" => {
+        "fetch" => lambda { |_url, _fetchdef|
+          [{ "status" => 200, "statusText" => "OK", "headers" => {},
+             "json" => lambda { { "ok" => true } } }, nil]
+        },
+      },
+    })
+  end
+
+  # Half the threads register their secrets; the rest run body until those
+  # are done or it returns false. Returns what the threads raised.
+  def while_registering(utility, root, &body)
+    lock = Mutex.new
+    registering = WIDTH / 2
+    at_once do |n|
+      if n < WIDTH / 2
+        begin
+          ADDED.times { |k| utility.clean_add.call(root, "ADDED-SECRET-#{n}-#{k}") }
+        ensure
+          lock.synchronize { registering -= 1 }
+        end
+      else
+        while 0 < lock.synchronize { registering }
+          break unless body.call(n)
+          Thread.pass
+        end
+      end
+    end
+  end
+
+  def assert_every_secret_masked(utility, root)
+    (WIDTH / 2).times do |n|
+      ADDED.times do |k|
+        added = "ADDED-SECRET-#{n}-#{k}"
+        assert_equal "[redacted]", utility.clean.call(root, added), "#{added} was registered but not masked"
+      end
+    end
+  end
+
+  # Secrets registered on some threads while others clean: every clean masks
+  # what was registered before it, the longer secret whole, and no
+  # registration is lost.
+  def test_concurrent_registration_keeps_every_secret_masked
+    client = ProjectNameSDK.test(nil, nil)
+    utility = client.get_utility
+    root = client.get_root_ctx
+    SEEDED.times { |k| utility.clean_add.call(root, "SEEDED-SECRET-#{k}") }
+    utility.clean_add.call(root, "INNER-SECRET")
+    utility.clean_add.call(root, "OUTER-INNER-SECRET-TAIL")
+    text = "a INNER-SECRET b OUTER-INNER-SECRET-TAIL c"
+    assert_equal MASKED, utility.clean.call(root, text)
+
+    wrong = Queue.new
+    raised = while_registering(utility, root) do
+      got = utility.clean.call(root, text)
+      wrong << got if MASKED != got
+      MASKED == got
+    end
+
+    cleaned = Array.new(wrong.size) { wrong.pop }
+    assert_empty raised, "raised: #{raised.inspect}"
+    assert_empty cleaned, "cleaned to: #{cleaned.inspect}"
+    assert_every_secret_masked(utility, root)
+  end
+
+  # Requests on one client while secrets register on it: each request copies
+  # the client's options, the registry among them.
+  def test_concurrent_requests_survive_registration
+    client = live_client
+    utility = client.get_utility
+    root = client.get_root_ctx
+    SEEDED.times { |k| utility.clean_add.call(root, "SEEDED-SECRET-#{k}") }
+
+    failed = Queue.new
+    raised = while_registering(utility, root) do |n|
+      res = client.direct({ "path" => "p#{n}" })
+      failed << res unless true == res["ok"]
+      true == res["ok"]
+    end
+
+    requests = Array.new(failed.size) { failed.pop }
+    assert_empty raised, "raised: #{raised.inspect}"
+    assert_empty requests, "a request failed: #{requests.inspect}"
+    assert_every_secret_masked(utility, root)
+  end
+end

package/project/.sdk/tm/rb/test/feature_corpus_test.rb

@@ -25,11 +25,11 @@ class FeatureCorpusTest < Minitest::Test
   # generated without a listed feature still skips, not fails.
 
   # The standard operation names, in the order the runner prefers them.
-  FEATURE_CORPUS_OPS = %w[load list create update remove].freeze
+  FEATURE_CORPUS_OPS = %w[load list create update patch remove].freeze
 
   def corpus
     @corpus ||= JSON.parse(
-      File.read(File.join(__dir__, "..", "..", ".sdk", "test", "test.json")))
+      File.read(File.join(__dir__, "..", "..", ".sdk", "test", "test.json"), encoding: "UTF-8"))
   end
 
   # A scripted transport built from a case's `res` list. Responses are
@@ -218,6 +218,30 @@ class FeatureCorpusTest < Minitest::Test
     client.instance_variable_get(:"@_#{name}")
   end
 
+  # The first feature a case composes that this SDK does not generate,
+  # probed as a section's own feature is. Such a case is skipped rather than
+  # failed.
+  def missing_feature(kase, have)
+    spec = kase["feature"]
+    names = if spec.is_a?(Array)
+              spec.map { |f| f.is_a?(Hash) ? f["name"] : nil }
+            elsif spec.is_a?(Hash)
+              spec.keys.sort
+            else
+              []
+            end
+    names.each do |name|
+      next unless name.is_a?(String)
+
+      unless have.key?(name)
+        probe = build_client({ "feature" => [{ "name" => name, "active" => true }] })
+        have[name] = present?(probe, name)
+      end
+      return name unless have[name]
+    end
+    nil
+  end
+
   def test_corpus_carries_a_feature_section
     # A corpus with no `feature` section is a SKIP, not a failure. Each
     # project carries its OWN materialised copy of .sdk/test/test.json, so a
@@ -241,6 +265,8 @@ class FeatureCorpusTest < Minitest::Test
   end
 
   def test_feature_corpus
+    failed = []
+    have = {}
     (corpus["feature"] || {}).keys.sort.each do |name|
       section = (corpus["feature"] || {})[name]
       next if section.nil?
@@ -265,49 +291,67 @@ class FeatureCorpusTest < Minitest::Test
       ran = 0
       cases.each do |raw|
         need = tokens_used(raw)
-        next if need > ops.length
+        if need > ops.length
+          puts "skip \"#{raw['name']}\": needs #{need} operations, this SDK offers #{ops.length}"
+          next
+        end
+
+        missing = missing_feature(raw, have)
+        unless missing.nil?
+          puts "skip \"#{raw['name']}\": needs the #{missing} feature, " \
+               "which this SDK does not generate"
+          next
+        end
 
         tokens = {}
         need.times { |i| tokens["#OP#{i + 1}"] = ops[i]["key"] }
         kase = resolve(raw, tokens)
+        label = kase["name"].to_s
+        ran += 1
 
-        client = build_client(kase)
-        label = kase["name"]
-
-        (kase["op"] || []).each do |step|
-          op = by_key[step["op"]]
-          refute_nil op, "#{label}: no operation #{step['op']}"
-          ctrl = step["ctrl"] || {}
-          wanterr = step["err"]
-
-          begin
-            invoke(client, op, ctrl)
-            assert_nil wanterr, "#{label}: #{step['op']} was expected to fail, and did not"
-          rescue Minitest::Assertion
-            raise
-          rescue StandardError => e
-            refute_nil wanterr, "#{label}: #{step['op']} failed unexpectedly: #{e}"
-            if wanterr.is_a?(String)
-              # The CODE, not the message: make_error prefixes and humanises
-              # the text, so matching it would pass on any error that
-              # happened to mention the word.
-              code = e.respond_to?(:code) ? e.code : nil
-              assert_equal wanterr, code,
-                           "#{label}: wrong error code (#{e})"
+        # Every failing case is reported, not only the first.
+        begin
+          client = build_client(kase)
+
+          (kase["op"] || []).each do |step|
+            op = by_key[step["op"]]
+            refute_nil op, "#{label}: no operation #{step['op']}"
+            ctrl = step["ctrl"] || {}
+            wanterr = step["err"]
+
+            begin
+              invoke(client, op, ctrl)
+              assert_nil wanterr, "#{label}: #{step['op']} was expected to fail, and did not"
+            rescue Minitest::Assertion
+              raise
+            rescue StandardError => e
+              refute_nil wanterr, "#{label}: #{step['op']} failed unexpectedly: #{e}"
+              if wanterr.is_a?(String)
+                # The CODE, not the message: make_error prefixes and humanises
+                # the text, so matching it would pass on any error that
+                # happened to mention the word.
+                code = e.respond_to?(:code) ? e.code : nil
+                assert_equal wanterr, code,
+                             "#{label}: wrong error code (#{e})"
+              end
             end
           end
-        end
 
-        subset(record(client, name), kase["out"], "#{label}: _#{name}")
-        ran += 1
+          subset(record(client, name), kase["out"], "#{label}: _#{name}")
+        rescue Minitest::Assertion, StandardError => e
+          failed << (e.message.start_with?(label) ? e.message : "#{label}: #{e.message}")
+        end
       end
 
-      assert ran > 0, "every feature.#{name} case was skipped"
       # Say how many ran. A partial run is legitimate (an SDK with one
       # operation skips the cases needing two) but it should be visible
       # rather than inferred from a green tick.
       puts "feature.#{name}: ran #{ran} of #{cases.length} case(s) " \
            "against #{ops.length} operation(s)"
+      failed << "every feature.#{name} case was skipped" if ran.zero?
     end
+
+    assert failed.empty?,
+           "#{failed.length} feature corpus case(s) failed:\n  #{failed.join("\n  ")}"
   end
 end

package/project/.sdk/tm/rb/test/feature_test.rb

@@ -21,7 +21,7 @@ module ProjectNameFeatureHarness
 
   def self.default_method(opname)
     return "POST" if opname == "create"
-    return "PATCH" if opname == "update"
+    return "PATCH" if opname == "update" || opname == "patch"
     return "DELETE" if opname == "remove"
     "GET"
   end