graph_weaver 0.5.0 → 0.6.0

data/lib/graph_weaver/testing/cassette.rb

@@ -14,13 +14,14 @@ module GraphWeaver
     class MissingRecording < GraphWeaver::Error
       # how many recorded variable sets to print before summarizing
       SHOWN = 5
+      private_constant :SHOWN
 
       def initialize(path:, query:, variables:, recorded:, size:)
         super([
-          "no recording for this request in #{path}",
-          "  variables: #{Cassette.normalize_variables(variables).inspect}",
+          "no recording for this request in #{GraphWeaver::Internal::Util.relative(path)}",
+          "  variables: #{GraphWeaver::Internal::Log.filter_variables(Internal::RequestKey.normalize_variables(variables)).inspect}",
           "  #{self.class.recorded_summary(recorded, size)}",
-          "  query: #{Cassette.summarize(query)}",
+          "  query: #{Internal::RequestKey.summarize(query)}",
           "re-record it (GRAPHWEAVER_RECORD=1 with a client:), or delete the cassette to start over.",
         ].join("\n"))
       end
@@ -29,8 +30,9 @@ module GraphWeaver
         return "no entry recorded for this query (#{size} in the cassette)" if recorded.empty?
 
         more = recorded.size > SHOWN ? " (+#{recorded.size - SHOWN} more)" : ""
+        shown = recorded.first(SHOWN).map { |set| GraphWeaver::Internal::Log.filter_variables(set).inspect }
         "#{recorded.size} #{(recorded.size == 1) ? "entry" : "entries"} recorded for this query, " \
-          "with variables #{recorded.first(SHOWN).map(&:inspect).join(", ")}#{more}"
+          "with variables #{shown.join(", ")}#{more}"
       end
     end
 
@@ -51,15 +53,17 @@ module GraphWeaver
         elsif config.record
           # record mode without a client would quietly serve the stale
           # recording — the one thing "re-record everything" didn't ask for
-          raise GraphWeaver::Error, "record mode is on but no `client:` was given for #{file.path} " \
+          raise GraphWeaver::Error, "record mode is on but no `client:` was given for " \
+            "#{GraphWeaver::Internal::Util.relative(file.path)} " \
             "— pass a live `client:` to re-record it, or turn record mode off " \
             "(GRAPHWEAVER_RECORD / Testing.config.record)."
         elsif file.exist?
           Replayer.new(file)
         else
           # a first run, not a missing recording: there is no request yet
-          raise GraphWeaver::Error, "#{file.path} doesn't exist and no `client:` was given to " \
-            "record with — pass `client:` on the first run, or commit the cassette."
+          raise GraphWeaver::Error, "#{GraphWeaver::Internal::Util.relative(file.path)} doesn't exist " \
+            "and no `client:` was given to record with — pass `client:` on the first run, " \
+            "or commit the cassette."
         end
       end
     end
@@ -72,14 +76,14 @@ module GraphWeaver
       # found. `checked` is how many recordings a module claimed: a run that
       # claimed none proved nothing, which is a different answer from "all
       # good" — the same distinction `federation:diff` draws.
-      Check = Struct.new(:path, :checked, :skipped, :stale, keyword_init: true) do
+      Check = Data.define(:path, :checked, :skipped, :stale) do
         def ok? = stale.empty?
 
         def report
           counted = ["#{checked} checked"]
           counted << "#{skipped} not sent by any query module" if skipped.positive?
 
-          ["#{path}: #{stale.size} stale (#{counted.join(", ")})"] +
+          ["#{GraphWeaver::Internal::Util.relative(path)}: #{stale.size} stale (#{counted.join(", ")})"] +
             stale.flat_map do |entry|
               ["  #{entry.module_name} #{entry.variables.inspect}", "    #{entry.message}"]
             end
@@ -87,42 +91,66 @@ module GraphWeaver
       end
 
       # One recording the generated structs can no longer read.
-      Stale = Struct.new(:module_name, :variables, :message, keyword_init: true)
+      Stale = Data.define(:module_name, :variables, :message)
+
+      # Shapes that are a credential whatever the field around them is
+      # called. Anonymization can't cover everything a cassette holds — the
+      # variables ARE the replay key, so they're written verbatim — so the
+      # bytes that reach disk get one look before anyone commits them.
+      # Deliberately narrow: a false alarm costs a glance, while a password
+      # like "hunter2" has no shape at all, so a quiet run is not a clean
+      # bill of health.
+      CREDENTIAL_SHAPES = {
+        "a JWT" => /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\./,
+        "an AWS access key" => /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/,
+        "a GitHub token" => /\b(?:gh[opusr]|github_pat)_[A-Za-z0-9_]{20,}/,
+        "a Slack token" => /\bxox[baprs]-[A-Za-z0-9-]{10,}/,
+        "a Stripe key" => /\bsk_(?:live|test)_[A-Za-z0-9]{10,}/,
+        "a private key" => /-----BEGIN [A-Z ]*PRIVATE KEY-----/,
+        "an Authorization header" => /\bBearer\s+\S{16,}/,
+      }.freeze
 
       attr_reader :path
 
       def initialize(path)
         @path = Testing.cassette_path(path)
         @entries = File.exist?(@path) ? YAML.safe_load_file(@path, aliases: true) : []
+        @flagged = []
+        # record is read-modify-write; two threads recording through one
+        # cassette (a parallel spec run) would each save a snapshot missing
+        # the other's entry — atomic_write keeps the file whole, not complete
+        @lock = Mutex.new
       end
 
       def exist? = File.exist?(@path)
       def size = @entries.size
 
       def lookup(query, variables, operation_name = nil)
-        wanted = self.class.key(query, variables, operation_name)
-        @entries.find { |entry| self.class.entry_key(entry) == wanted }
+        wanted = Internal::RequestKey.for(query, variables, operation_name)
+        @entries.find { |entry| Internal::RequestKey.for_entry(entry) == wanted }
       end
 
       # every variables hash recorded for this query — what a miss needs
       # to show, since the variables are what usually differ
       def variants(query, operation_name = nil)
-        normalized = self.class.normalize_query(query)
+        normalized = Internal::RequestKey.normalize_query(query)
         @entries.select do |entry|
-          self.class.normalize_query(entry["query"]) == normalized && entry["operationName"] == operation_name
+          Internal::RequestKey.normalize_query(entry["query"]) == normalized && entry["operationName"] == operation_name
         end.map { |entry| entry["variables"] || {} }
       end
 
       def record(query, variables, response, operation_name = nil)
         entry = { "query" => query }
         entry["operationName"] = operation_name if operation_name
-        entry["variables"] = self.class.normalize_variables(variables)
+        entry["variables"] = Internal::RequestKey.normalize_variables(variables)
         entry["response"] = response
 
-        wanted = self.class.key(query, variables, operation_name)
-        @entries.reject! { |existing| self.class.entry_key(existing) == wanted }
-        @entries << entry
-        save
+        wanted = Internal::RequestKey.for(query, variables, operation_name)
+        @lock.synchronize do
+          @entries.reject! { |existing| Internal::RequestKey.for_entry(existing) == wanted }
+          @entries << entry
+          save
+        end
       end
 
       # Replay every recording through `modules` — the generated query
@@ -138,10 +166,10 @@ module GraphWeaver
       # Matching is on the query text, which is the module that sent it — a
       # recording no module sends is skipped rather than guessed at.
       def check(modules)
-        index = modules.to_h { |mod| [self.class.normalize_query(mod.const_get(:QUERY)), mod] }
+        index = modules.to_h { |mod| [Internal::RequestKey.normalize_query(mod.const_get(:QUERY)), mod] }
         checked = 0
         stale = @entries.filter_map do |entry|
-          mod = index[self.class.normalize_query(entry["query"])] or next
+          mod = index[Internal::RequestKey.normalize_query(entry["query"])] or next
           checked += 1
 
           begin
@@ -158,51 +186,37 @@ module GraphWeaver
       # Replace recorded response values with fakes, preserving structure.
       # Walks each entry's query against the schema (like FakeClient,
       # but transforming what's there instead of generating from scratch).
-      def anonymize!(schema:, seed: nil, mode: nil)
-        anonymizer = Anonymizer.new(schema:, seed:, mode:)
+      def anonymize!(schema:, seed: nil, values: nil)
+        anonymizer = Anonymizer.new(schema:, seed:, values:)
         @entries.each do |entry|
-          data = entry.dig("response", "data")
-          entry["response"]["data"] = anonymizer.anonymize(entry["query"], data) if data
+          entry["response"] = anonymizer.anonymize(entry["query"], entry["response"]) if entry["response"]
         end
         save
         self
       end
 
-      # The request's identity, exactly as the server sees it. operationName
-      # is part of that: it picks the operation the document runs, so two
-      # requests with identical text but different names are different
-      # requests. Derived, never stored — the file holds the request once,
-      # so a hand-edited entry can't disagree with what replay matches on.
-      def self.key(query, variables, operation_name = nil)
-        key = { "query" => normalize_query(query), "variables" => normalize_variables(variables) }
-        key["operationName"] = operation_name if operation_name
-        key
-      end
-
-      def self.entry_key(entry)
-        key(entry["query"], entry["variables"], entry["operationName"])
-      end
-
-      def self.normalize_query(query) = query.gsub(/\s+/, " ").strip
-
-      # one readable line: an error naming a 60-line query is a wall, not a hint
-      def self.summarize(query, limit: 160)
-        normalized = normalize_query(query)
-        (normalized.length > limit) ? "#{normalized[0, limit]}…" : normalized
-      end
-
-      # JSON round-trip so symbol keys become strings — otherwise YAML.dump
-      # writes Ruby symbols the safe loader rejects on the next run, and lookup
-      # keys stay stable across processes
-      def self.normalize_variables(variables)
-        JSON.parse(JSON.generate(variables || {}))
-      end
-
       private
 
       def save
+        yaml = YAML.dump(@entries)
         FileUtils.mkdir_p(File.dirname(@path))
-        File.write(@path, YAML.dump(@entries))
+        GraphWeaver::Internal::Util.atomic_write(@path, yaml)
+        flag_credentials(yaml)
+      end
+
+      # Once per shape per cassette: a recording run saves after every
+      # request, and one line is a warning where forty is noise. On stderr
+      # rather than GraphWeaver.logger — the logger is silent by default,
+      # and this has to reach whoever is about to commit the file.
+      def flag_credentials(yaml)
+        found = CREDENTIAL_SHAPES.reject { |name, _| @flagged.include?(name) }
+          .select { |_, pattern| pattern.match?(yaml) }.keys
+        return if found.empty?
+
+        @flagged.concat(found)
+        warn "graph_weaver: #{GraphWeaver::Internal::Util.relative(@path)} contains #{found.join(", ")} — a cassette is committed as " \
+          "written, so review this one first. Testing.config.anonymize scrubs the response; the " \
+          "query and variables are the replay key and are recorded verbatim."
       end
     end
 
@@ -227,9 +241,7 @@ module GraphWeaver
 
       def execute(query, variables: {}, operation_name: nil)
         response = @client.execute(query, variables:, operation_name:).to_h
-        if @anonymizer && (data = response["data"])
-          response = response.merge("data" => @anonymizer.anonymize(query, data))
-        end
+        response = @anonymizer.anonymize(query, response) if @anonymizer
 
         @cassette.record(query, variables, response, operation_name)
         response
@@ -258,20 +270,54 @@ module GraphWeaver
     # fake values. Enums, booleans, __typename, and null positions are
     # preserved; ids map consistently so relationships survive.
     class Anonymizer
-      include GraphWeaver::Selection
+      include GraphWeaver::Internal::Selection
+
+      # Keys under `errors`/`extensions` whose value describes the request
+      # rather than carrying data: `path` and `locations` point into the
+      # document, and `code` is the errors-world enum — call sites branch on
+      # it exactly as they branch on an enum in `data`, which is preserved
+      # for the same reason.
+      VERBATIM_KEYS = %w[path locations code].freeze
 
-      def initialize(schema:, seed: nil, mode: nil)
+      def initialize(schema:, seed: nil, values: nil)
         @schema = schema
-        @values = Values.new(seed:, mode:)
+        @values = Internal::Values.new(seed:, values:)
       end
 
-      def anonymize(query, data)
-        operation = load_operation(query)
+      # The whole response, not just `data`: an error message routinely
+      # quotes the input that caused it, and `extensions` is whatever the
+      # server felt like attaching. One rule — `data` is walked against the
+      # schema, everything else by shape.
+      def anonymize(query, response)
+        response.to_h do |key, value|
+          [key, (key == "data") ? data_value(query, value) : untyped_value(key, value)]
+        end
+      end
+
+      private
 
+      def data_value(query, data)
+        return if data.nil?
+
+        operation = load_operation(query)
         object_value(operation_root_type(operation), operation.selections, data)
       end
 
-      private
+      # No schema stands behind errors or extensions, so shape is all there
+      # is to preserve: keys, nesting, list lengths, nulls and booleans
+      # survive; every string and number is replaced.
+      def untyped_value(key, value)
+        return value if VERBATIM_KEYS.include?(key)
+
+        case value
+        when Hash then value.to_h { |name, nested| [name, untyped_value(name, nested)] }
+        when Array then value.map { |element| untyped_value(key, element) }
+        when String then @values.scalar("String", key)
+        when Integer then @values.scalar("Int", key)
+        when Float then @values.scalar("Float", key)
+        else value
+        end
+      end
 
       # Anonymization walks recorded data, not a live dispatch. When the query
       # narrows an abstract type without selecting __typename (`named { name
@@ -295,54 +341,61 @@ module GraphWeaver
         end
 
         result = {}
-        each_field(type, selections) do |key, node|
+        # gather (not each_field) so a key selected twice — `a { x } a { y }` —
+        # keeps the MERGED shape codegen's struct expects, not last-writer-wins
+        gather(type, selections).each do |key, nodes|
           next unless data.key?(key)
 
+          node = nodes.first
           result[key] = if node.name == "__typename"
             data[key]
           else
-            field_value(type, node, data[key])
+            field_value(type, node.name, nodes.flat_map(&:selections), data[key])
           end
         end
 
         result
       end
 
-      def field_value(parent_type, node, value)
+      def field_value(parent_type, name, selections, value)
         # a field from a `... on Member` fragment lives on the member, not the
         # abstract type we're walking (no __typename to narrow by), so fall back
         # to whichever possible type declares it
-        field = @schema.get_field(parent_type.graphql_name, node.name) ||
-          @schema.possible_types(parent_type).filter_map { |t| @schema.get_field(t.graphql_name, node.name) }.first
-        type_value(field.type, node, value)
+        field = @schema.get_field(parent_type.graphql_name, name) ||
+          @schema.possible_types(parent_type).filter_map { |t| @schema.get_field(t.graphql_name, name) }.first
+        type_value(field.type, name, selections, value, "#{parent_type.graphql_name}.#{name}")
       end
 
-      def type_value(type, node, value)
+      def type_value(type, name, selections, value, coordinate = nil)
         return if value.nil? # preserve null positions
 
         case type.kind.name
         when "NON_NULL"
-          type_value(type.of_type, node, value)
+          type_value(type.of_type, name, selections, value, coordinate)
         when "LIST"
-          value.map { |element| type_value(type.of_type, node, element) }
+          value.map { |element| type_value(type.of_type, name, selections, element, coordinate) }
         when "SCALAR"
-          scalar_value(type.graphql_name, node.name, value)
+          scalar_value(type.graphql_name, name, value, coordinate)
         when "ENUM"
           value # enums aren't PII; preserving them keeps semantics
         when "OBJECT", "UNION", "INTERFACE"
-          object_value(type, node.selections, value)
+          object_value(type, selections, value)
         else
           value
         end
       end
 
-      def scalar_value(type_name, field_name, value)
+      def scalar_value(type_name, field_name, value, coordinate = nil)
         case type_name
         when "ID" then @values.mapped_id(value)
         when "Boolean" then value # not PII; preserves branching behavior
-        else @values.scalar(type_name, field_name)
+        else @values.scalar(type_name, field_name, coordinate)
         end
       end
     end
+
+    # the scrubbing walk anonymize! runs — reached through a cassette,
+    # never named
+    private_constant :Anonymizer
   end
 end

data/lib/graph_weaver/testing/coverage.rb

@@ -26,7 +26,7 @@ module GraphWeaver
       # plan stitches across a boundary. `absent` names the subgraphs that
       # plan reaches which nothing in this process serves — plannable and
       # runnable-here are different questions.
-      Result = Struct.new(:path, :subgraph, :absent, :category, :detail) do
+      Result = Data.define(:path, :subgraph, :absent, :category, :detail) do
         def servable? = category.nil? && absent.empty?
       end
 
@@ -35,32 +35,26 @@ module GraphWeaver
         .transform_values(&:first)
         .merge(invalid: "doesn't validate against the supergraph")
         .freeze
+      private_constant :LABELS
 
       attr_reader :results
 
       def initialize(supergraph:, queries: GraphWeaver.queries_paths, fragments: GraphWeaver.fragments_paths)
         source = supergraph.to_s
         table = GraphWeaver::SchemaLoader.routing_table(source)
-        unless table.unsupported.empty?
-          # the same refusal the Router makes at construction: with the table
-          # incomplete, every number this would report is a guess
-          raise Unplannable.new(
-            "this supergraph uses federation constructs the local router doesn't read: " +
-              table.unsupported.join("; "),
-            category: :unsupported_federation,
-          )
-        end
+        # with the table incomplete, every number this would report is a guess
+        Unplannable.unsupported!(table)
 
         # Planning still runs with `absent` empty — a query is plannable or
         # not whoever is serving. Which subgraphs are *here* is asked
         # separately, from evidence (a loaded schema defining what the table
         # says one resolves), and never refuses: with nothing loaded the
         # answer is simply "none", which is the SDL-alone CI run.
-        @planner = Router::Planner.new(table:, schema: GraphWeaver::SchemaLoader.load(source))
-        @absent = table.subgraphs.reject { |name| Subgraphs.candidates(table, name).any? }
+        @planner = Internal::Planner.new(table:, schema: GraphWeaver::SchemaLoader.load(source))
+        @absent = table.subgraphs.reject { |name| Internal::Subgraphs.served?(table, name) }
         @local = @absent.size < table.subgraphs.size
         @shared = GraphWeaver::Codegen.load_fragments(fragments)
-        @results = GraphWeaver.query_files(queries).map { |path| measure(path) }
+        @results = GraphWeaver::Internal::Util.query_files(queries).map { |path| measure(path) }
       end
 
       def plannable = @results.count { |result| result.category.nil? }
@@ -144,8 +138,10 @@ module GraphWeaver
       # the directory every query came from, so the report's file column is
       # filenames rather than the same path repeated
       def shared_dir
-        dirs = @results.map { |result| File.dirname(result.path) }.uniq
-        dirs.one? ? "#{dirs.first}/" : ""
+        @shared_dir ||= begin
+          dirs = @results.map { |result| File.dirname(result.path) }.uniq
+          dirs.one? ? "#{dirs.first}/" : ""
+        end
       end
 
       def measure(path)

data/lib/graph_weaver/testing/failure.rb

@@ -22,19 +22,23 @@ module GraphWeaver
       include Kernel # for sorbet
       module_function
 
-      # the request never reaches the server — cause preserved, like the
-      # bundled transports do
+      # the request never reaches the server — cause preserved, and the
+      # message shaped as the bundled transports shape it
       def transport(message = "simulated network failure", cause: SocketError)
         FailureClient.new do
           raise cause, message
         rescue cause => e
-          raise GraphWeaver::TransportError, e.message
+          raise GraphWeaver::TransportError, "#{e.class}: #{e.message}"
         end
       end
 
-      # the server answered non-2xx
-      def server(status: 500, body: "simulated server error")
-        FailureClient.new { raise GraphWeaver::ServerError.new(status:, body:) }
+      # The server answered non-2xx. headers: is where the answer to "wait,
+      # then" lives — ServerError#retry_after and #throttled? read it, so a
+      # backoff is only exercised by a failure that carries one:
+      #
+      #      Failure.server(status: 429, headers: { "retry-after" => "2" })
+      def server(status: 500, body: "simulated server error", headers: {})
+        FailureClient.new { raise GraphWeaver::ServerError.new(status:, body:, headers:) }
       end
 
       # top-level GraphQL errors: strings, or hashes with message/path/
@@ -51,8 +55,10 @@ module GraphWeaver
       end
 
       def throttled
-        # array-wrapped so the hash can't parse as kwargs
-        graphql([{ message: "rate limited", extensions: { code: "THROTTLED" } }])
+        # a code from the list #throttled? recognizes, not one spelled here —
+        # a fake that doesn't trip the predicate it exists to exercise is worse
+        # than no fake. (array-wrapped so the hash can't parse as kwargs)
+        graphql([{ message: "rate limited", extensions: { code: GraphWeaver::GraphQLError::THROTTLE_CODES.first } }])
       end
 
       # A validation-shaped rejection — trips schema_stale? and its