graph_weaver 0.5.1 → 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,7 +91,7 @@ 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
@@ -112,35 +116,41 @@ module GraphWeaver
         @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
@@ -156,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
@@ -176,8 +186,8 @@ 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|
           entry["response"] = anonymizer.anonymize(entry["query"], entry["response"]) if entry["response"]
         end
@@ -185,42 +195,12 @@ module GraphWeaver
         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)
+        GraphWeaver::Internal::Util.atomic_write(@path, yaml)
         flag_credentials(yaml)
       end
 
@@ -234,7 +214,7 @@ module GraphWeaver
         return if found.empty?
 
         @flagged.concat(found)
-        warn "graph_weaver: #{@path} contains #{found.join(", ")} — a cassette is committed as " \
+        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
@@ -290,7 +270,7 @@ 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
@@ -299,9 +279,9 @@ module GraphWeaver
       # 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
 
       # The whole response, not just `data`: an error message routinely
@@ -383,19 +363,19 @@ module GraphWeaver
         # to whichever possible type declares it
         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)
+        type_value(field.type, name, selections, value, "#{parent_type.graphql_name}.#{name}")
       end
 
-      def type_value(type, name, selections, 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, name, selections, value)
+          type_value(type.of_type, name, selections, value, coordinate)
         when "LIST"
-          value.map { |element| type_value(type.of_type, name, selections, element) }
+          value.map { |element| type_value(type.of_type, name, selections, element, coordinate) }
         when "SCALAR"
-          scalar_value(type.graphql_name, 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"
@@ -405,13 +385,17 @@ module GraphWeaver
         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,6 +35,7 @@ module GraphWeaver
         .transform_values(&:first)
         .merge(invalid: "doesn't validate against the supergraph")
         .freeze
+      private_constant :LABELS
 
       attr_reader :results
 
@@ -49,11 +50,11 @@ module GraphWeaver
         # 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.served?(table, name) }
+        @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? }

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/