@voxgig/sdkgen 4.34.0 → 4.34.1

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

@@ -88,7 +88,7 @@ class ProjectNameContext
 
     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)

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/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

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

@@ -9,7 +9,7 @@ module ProjectNameTestRunner
     env_file = File.join(File.dirname(__FILE__), '..', '..', '.env.local')
     return unless File.exist?(env_file)
 
-    File.readlines(env_file).each do |line|
+    File.readlines(env_file, encoding: 'UTF-8').each do |line|
       line = line.strip
       next if line.empty? || line.start_with?('#')
       key, val = line.split('=', 2)
@@ -71,7 +71,7 @@ module ProjectNameTestRunner
     return @test_control unless @test_control.nil?
     ctrl_path = File.join(File.dirname(__FILE__), 'sdk-test-control.json')
     @test_control = begin
-      JSON.parse(File.read(ctrl_path))
+      JSON.parse(File.read(ctrl_path, encoding: 'UTF-8'))
     rescue StandardError
       {
         'version' => 1,
@@ -133,6 +133,58 @@ module ProjectNameTestRunner
     return v if v.is_a?(Integer) && v >= 0
     500
   end
+
+  # A live check that did not pass, as main.kit.test.live.strict decides:
+  # strict fails the test, lenient skips it with the same reason.
+  def self.live_miss(strict, reason)
+    raise Minitest::Assertion, reason if strict
+    raise Minitest::Skip, reason
+  end
+
+  # An account holding no record for the test to read skips either way.
+  def self.live_empty(reason)
+    raise Minitest::Skip, reason
+  end
+
+  # A live list response's records: the body, or the first list an
+  # envelope holds.
+  def self.live_list(data)
+    return data if data.is_a?(Array)
+    return data.values.find { |v| v.is_a?(Array) } if data.is_a?(Hash)
+    nil
+  end
+
+  # A live response for a message: the SDK's error, or else its status and
+  # content type, never its body.
+  def self.live_describe(result)
+    return "no response" unless result.is_a?(Hash)
+    err = result["err"]
+    return (err.respond_to?(:message) ? err.message : err.to_s) unless err.nil?
+    headers = result["headers"].is_a?(Hash) ? result["headers"] : {}
+    ctype = headers.find { |k, _v| k.to_s.downcase == "content-type" }&.last
+    "HTTP #{result["status"]}" + (ctype ? " #{ctype.to_s.split(";").first.strip}" : "")
+  end
+
+  # The record a create-less flow reads live: the first its list returns,
+  # put where the flow reads the fixture's existing records.
+  def self.live_existing(setup, strict, name)
+    found = begin
+      yield
+    rescue StandardError => e
+      live_miss(strict, "Live list discovery failed: #{e.message}")
+    end
+    live_miss(strict, "Live list discovery returned no list") unless found.is_a?(Array)
+    live_empty("The account has no #{name} record to load") if found.empty?
+    first = found[0]
+    record = first.respond_to?(:data_get) ? first.data_get : first
+    (setup[:data]["existing"] ||= {})[name] = { "live01" => record }
+  end
+
+  # In a lenient live run a failing check skips, observing the live API.
+  def self.live_observe(error, setup, strict)
+    raise error if strict || !setup.is_a?(Hash) || !setup[:live] || error.is_a?(Minitest::Skip)
+    raise Minitest::Skip, "live run, main.kit.test.live.strict is false: #{error.message}"
+  end
 end
 
 # Module-level aliases for test convenience.

package/project/.sdk/tm/rb/utility/clean.rb

@@ -289,18 +289,26 @@ module ProjectNameUtilities
 
     # A feature's name is not a field name: only the sensitive names inside
     # its settings count, so `secrets` does not make every setting a secret.
-    # Entity blocks (per-entity settings, seeded records) hold no credential.
+    # Entity blocks (per-entity settings, seeded records) hold no credential,
+    # and nor do rbac's rules, keyed by entity and operation names.
     def self.add_options(ctx, opts)
       top = opts.reject { |k, _| k == "feature" || k == "entity" }
-      top["test"] = no_entity(top["test"]) if top.key?("test")
+      top["test"] = plain_settings(top["test"], nil) if top.key?("test")
       add_sensitive(ctx, top)
       feature = opts["feature"]
-      blocks = feature.is_a?(Hash) ? feature.values : (feature.is_a?(Array) ? feature : [feature])
-      blocks.each { |fopts| add_sensitive(ctx, no_entity(fopts)) }
+      blocks = if feature.is_a?(Hash)
+                 feature.to_a
+               elsif feature.is_a?(Array)
+                 feature.map { |b| [b.is_a?(Hash) ? b["name"] : nil, b] }
+               else
+                 [[nil, feature]]
+               end
+      blocks.each { |name, fopts| add_sensitive(ctx, plain_settings(fopts, name)) }
     end
 
-    def self.no_entity(block)
-      block.is_a?(Hash) ? block.reject { |k, _| k == "entity" } : block
+    def self.plain_settings(block, name)
+      return block unless block.is_a?(Hash)
+      block.reject { |k, _| k == "entity" || (name == "rbac" && k == "rules") }
     end
 
     # Is this key name sensitive under the context's clean configuration?

package/project/.sdk/tm/rb/utility/fetcher.rb

@@ -68,9 +68,22 @@ module ProjectNameUtilities
         request[k] = v.to_s
       end
       # Default User-Agent — Net::HTTP sets "Ruby" which some CDNs block.
-      # Use a Mozilla-shaped UA unless the caller already set one.
-      request['User-Agent'] = 'Mozilla/5.0 (compatible; ProjectNameSDK/1.0)' unless has_ua
-      request.body = body_str if body_str.is_a?(String)
+      # Use a Mozilla-shaped UA unless the caller already set one, and record
+      # it with the headers the request sent.
+      unless has_ua
+        request['User-Agent'] = 'Mozilla/5.0 (compatible; ProjectNameSDK/1.0)'
+        fetchdef["headers"]['user-agent'] = request['User-Agent'] if fetchdef["headers"].is_a?(Hash)
+      end
+      if body_str.is_a?(String)
+        request.body = body_str
+      elsif body_str.respond_to?(:read)
+        request.body_stream = body_str
+        if body_str.respond_to?(:size)
+          request['Content-Length'] = body_str.size.to_s
+        else
+          request['Transfer-Encoding'] = 'chunked'
+        end
+      end
 
       http = ProjectNameUtilities.http_checkout(key, uri, proxy)
       begin
@@ -86,9 +99,11 @@ module ProjectNameUtilities
       resp.each_header { |k, v| resp_headers[k.downcase] = v }
 
       json_body = nil
+      unreadable = false
       begin
-        json_body = JSON.parse(resp.body) if resp.body && !resp.body.empty?
+        json_body = JSON.parse(resp.body) if resp.body && !resp.body.strip.empty?
       rescue JSON::ParserError
+        unreadable = true
       end
 
       return {
@@ -97,18 +112,11 @@ module ProjectNameUtilities
         "headers" => resp_headers,
         "json" => -> { json_body },
         "body" => resp.body,
+        "unreadable" => unreadable,
       }, nil
     rescue StandardError => e
-      # Network-level failures (DNS, TCP, TLS, timeouts) — return a synthesized
-      # response with status 0 so callers can branch on result.ok like any
-      # other failed request, instead of seeing an unhandled exception.
-      return {
-        "status" => 0,
-        "statusText" => "#{e.class}: #{e.message}",
-        "headers" => {},
-        "json" => -> { nil },
-        "body" => nil,
-      }, nil
+      # A request that got no answer (DNS, TCP, TLS, a timeout) fails the operation.
+      return nil, "#{e.class}: #{e.message}"
     end
   }