graph_weaver 0.0.1 → 0.2.0

data/lib/graph_weaver/testing/failure.rb

@@ -0,0 +1,109 @@
+# typed: true
+# frozen_string_literal: true
+
+require "json"
+
+module GraphWeaver
+  module Testing
+    # Canned failure clients — each produces exactly what the real
+    # transports produce, so error-handling paths are testable without a
+    # server that misbehaves on cue:
+    #
+    #      PersonQuery.execute(id: "1", Failure.transport)   # TransportError
+    #      PersonQuery.execute(id: "1", Failure.server(status: 502))
+    #      PersonQuery.execute(id: "1", Failure.throttled)   # QueryError, code THROTTLED
+    #      PersonQuery.execute(id: "1", Failure.stale_schema) # schema_stale? => true
+    #
+    # For type mismatches, corrupt the wire with a FakeClient override:
+    #      FakeClient.new(schema:, overrides: { "Person.birthday" => 123 })
+    # casting then raises GraphWeaver::TypeError, exactly as a bad server
+    # payload would. For partial failures, see FakeClient's fail_at:.
+    module Failure
+      include Kernel # for sorbet
+      module_function
+
+      # the request never reaches the server — cause preserved, like the
+      # bundled transports do
+      def transport(message = "simulated network failure", cause: SocketError)
+        FailureClient.new do
+          raise cause, message
+        rescue cause => e
+          raise GraphWeaver::TransportError, 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:) }
+      end
+
+      # top-level GraphQL errors: strings, or hashes with message/path/
+      # extensions; data: rides along for partial-failure envelopes
+      def graphql(*errors, data: nil, extensions: {})
+        normalized = errors.flatten.map do |error|
+          error.is_a?(String) ? { "message" => error } : JSON.parse(JSON.generate(error))
+        end
+
+        response = { "errors" => normalized }
+        response["data"] = data if data
+        response["extensions"] = JSON.parse(JSON.generate(extensions)) unless extensions.empty?
+        FailureClient.new { response }
+      end
+
+      def throttled
+        # array-wrapped so the hash can't parse as kwargs
+        graphql([{ message: "rate limited", extensions: { code: "THROTTLED" } }])
+      end
+
+      # A validation-shaped rejection — trips schema_stale? and its
+      # regenerate hint, as if the schema changed under the module. Name
+      # the casualty explicitly, or pass schema: to sample a real
+      # type/field (as if the server just dropped it):
+      #
+      #      Failure.stale_schema(type: "Person", field: "name")
+      #      Failure.stale_schema(schema: MySchema)             # random real field
+      #      Failure.stale_schema(schema: MySchema, seed: 42)   # reproducibly random
+      def stale_schema(field: nil, type: nil, schema: nil, seed: nil)
+        if schema && (field.nil? || type.nil?)
+          rng = Random.new(seed || GraphWeaver::Testing.config.seed || Random.new_seed)
+          candidates = schema.types.values.select do |candidate|
+            candidate.kind.name == "OBJECT" && !candidate.graphql_name.start_with?("__")
+          end
+          chosen = candidates.sort_by(&:graphql_name).sample(random: rng)
+          type ||= chosen.graphql_name
+          field ||= chosen.fields.keys.sort.sample(random: rng)
+        end
+
+        graphql("Field '#{field || "someField"}' doesn't exist on type '#{type || "SomeType"}'")
+      end
+    end
+
+    # runs the block per request — raise or return an envelope
+    class FailureClient
+      def initialize(&response)
+        @response = response
+      end
+
+      def execute(_query, variables: {})
+        @response.call
+      end
+    end
+
+    # Delegates each call to the next client in line (the last one
+    # repeats) — fail N times, then succeed, for retry/backoff testing:
+    #
+    #      Sequence.new(Failure.transport, Failure.transport, fake)
+    class Sequence
+      def initialize(*clients)
+        @clients = clients.flatten
+        @calls = 0
+      end
+
+      def execute(query, variables: {})
+        client = @clients[[@calls, @clients.size - 1].min]
+        @calls += 1
+        client.execute(query, variables:)
+      end
+    end
+  end
+end

data/lib/graph_weaver/testing/fake_client.rb

@@ -0,0 +1,228 @@
+# typed: true
+# frozen_string_literal: true
+
+require "graphql"
+require "json"
+
+# A fake client that fabricates schema-correct responses for whatever query
+# arrives — the zero-setup way to test code built on generated modules:
+#
+#      fake = GraphWeaver::Testing::FakeClient.new(schema:)
+#      result = PersonQuery.execute!(id: "1", fake — positionally)
+#      result.person.name  # => a plausible String, typed and castable
+#
+# Values are type-correct by construction (real enum values, valid
+# __typename members for unions/interfaces, iso8601 for date scalars), so
+# every fake response casts cleanly through the generated structs. See
+# Values for value fabrication (mode: :faker / :literal).
+#
+# overrides: pin fields by GraphQL name — schema vocabulary, so keys
+# survive query refactors. "Type.field" beats "field"; values are
+# literals or zero-arg procs. (An override with a wrong-typed value is
+# also the way to simulate a corrupt payload — casting raises
+# GraphWeaver::TypeError.)
+#
+#      FakeClient.new(schema:, overrides: {
+#        "Person.name" => "Daniel",
+#        "email" => -> { "test@example.com" },
+#      })
+#
+# Partial failures: fail_at simulates a field-level error with
+# spec-correct null propagation — the field's error lands in the errors
+# array (with its concrete path), the field becomes null, and nulls
+# bubble past non-null positions to the nearest nullable ancestor, just
+# like a real server:
+#
+#      FakeClient.new(schema:, fail_at: "person.pets.name")
+#      FakeClient.new(schema:, fail_at: { path: "person.email", message: "hidden", code: "PRIVATE" })
+#
+# errors: appends verbatim top-level errors alongside the fake data.
+#
+# Type mismatches: corrupt: names fields ("Type.field") that should
+# arrive wire-corrupted — a wrong-typed value derived from the schema,
+# so casting raises GraphWeaver::TypeError. One spec checks the failure
+# path; every other spec gets working data:
+#
+#      FakeClient.new(schema:, corrupt: "Person.birthday")
+#
+# seed: makes a run reproducible (also seeds faker). Per-instance options
+# fall back to GraphWeaver::Testing.config.
+class GraphWeaver::Testing::FakeClient
+  include GraphWeaver::Selection
+
+  # sentinel: a simulated failure bubbling up to the nearest nullable spot
+  NULL_BUBBLE = Object.new.freeze
+
+  def initialize(schema:, overrides: {}, seed: nil, mode: nil, list_size: nil, null_chance: nil,
+    errors: nil, fail_at: nil, corrupt: nil)
+    config = GraphWeaver::Testing.config
+    @schema = schema
+    @overrides = config.overrides.merge(overrides)
+    @values = GraphWeaver::Testing::Values.new(seed:, mode:)
+    @list_size = list_size || config.list_size
+    @null_chance = null_chance || config.null_chance
+    # NOT Array(): it would explode a bare Hash into key/value pairs
+    @extra_errors = wrap(errors).map { |error| normalize_error(error) }
+    @fail_at = wrap(fail_at).map { |spec| normalize_fail_spec(spec) }
+    @corrupt = wrap(corrupt)
+  end
+
+  def execute(query, variables: {})
+    operation = load_operation(query)
+    root_type = operation_root_type(operation)
+
+    @path = []
+    @failures = []
+    data = object_value(root_type, operation.selections)
+    data = nil if data.equal?(NULL_BUBBLE) # total propagation, like a real server
+
+    response = { "data" => data }
+    errors = @failures + @extra_errors
+    response["errors"] = errors unless errors.empty?
+    response
+  end
+
+  private
+
+  def rng = @values.rng
+
+  def wrap(value)
+    case value
+    when nil then []
+    when Array then value
+    else [value]
+    end
+  end
+
+  def normalize_error(error)
+    error.is_a?(String) ? { "message" => error } : JSON.parse(JSON.generate(error))
+  end
+
+  def normalize_fail_spec(spec)
+    spec.is_a?(String) ? { "path" => spec } : JSON.parse(JSON.generate(spec))
+  end
+
+  def object_value(type, selections)
+    result = {}
+    each_field(type, selections) do |key, node|
+      @path.push(key)
+      value = node.name == "__typename" ? type.graphql_name : field_value(type, node)
+      @path.pop
+
+      if value.equal?(NULL_BUBBLE)
+        # bubble past non-null fields to the nearest nullable ancestor
+        return NULL_BUBBLE if non_null_field?(type, node)
+
+        value = nil
+      end
+      result[key] = value
+    end
+
+    result
+  end
+
+  def non_null_field?(type, node)
+    return false if node.name == "__typename"
+
+    @schema.get_field(type.graphql_name, node.name).type.kind.name == "NON_NULL"
+  end
+
+  def field_value(parent_type, node)
+    if (spec = matching_failure)
+      @failures << {
+        "message" => spec["message"] || "simulated failure",
+        "path" => @path.dup,
+      }.merge(spec["code"] ? { "extensions" => { "code" => spec["code"] } } : {})
+      spec["triggered"] = true
+
+      return NULL_BUBBLE
+    end
+
+    override = @overrides.fetch("#{parent_type.graphql_name}.#{node.name}") do
+      @overrides[node.name]
+    end
+    return override.is_a?(Proc) ? override.call : override unless override.nil?
+
+    field_type = @schema.get_field(parent_type.graphql_name, node.name).type
+    if @corrupt.include?("#{parent_type.graphql_name}.#{node.name}")
+      return corrupt_value(field_type)
+    end
+
+    type_value(field_type, node)
+  end
+
+  # a value casting can't accept, derived from the field's own type — and
+  # wrapped per list layer so the corruption lands on the element cast
+  def corrupt_value(type)
+    case type.kind.name
+    when "NON_NULL" then corrupt_value(type.of_type)
+    when "LIST" then [corrupt_value(type.of_type)]
+    when "SCALAR"
+      case type.graphql_name
+      when "Int", "Float" then "not-a-number"
+      when "Boolean" then "not-a-boolean"
+      else 123 # breaks String/ID props and every string-wire custom scalar
+      end
+    when "ENUM" then "__NOT_A_REAL_VALUE__"
+    else [] # objects/unions: an Array fails Hash-shaped casting loudly
+    end
+  end
+
+  # first untriggered fail_at spec whose field chain (indices stripped)
+  # matches where we are
+  def matching_failure
+    chain = @path.reject { |segment| segment.is_a?(Integer) }.join(".")
+    @fail_at.find { |spec| !spec["triggered"] && spec["path"] == chain }
+  end
+
+  # honor pagination-ish arg semantics: first/last/limit with a literal
+  # int caps the fabricated list length
+  def list_length(node)
+    argument = node.arguments.find { |arg| %w[first last limit].include?(arg.name) }
+    return argument.value if argument && argument.value.is_a?(Integer)
+
+    rng.rand(@list_size)
+  end
+
+  def type_value(type, node, non_null: false)
+    case type.kind.name
+    when "NON_NULL"
+      type_value(type.of_type, node, non_null: true)
+    when "LIST"
+      elements = Array.new(list_length(node)) do |index|
+        @path.push(index)
+        element = type_value(type.of_type, node)
+        @path.pop
+        element
+      end
+
+      if elements.any? { |element| element.equal?(NULL_BUBBLE) }
+        # non-null elements bubble the whole list; nullable ones go nil
+        return NULL_BUBBLE if type.of_type.kind.name == "NON_NULL"
+
+        elements.map! { |element| element.equal?(NULL_BUBBLE) ? nil : element }
+      end
+      elements
+    else
+      return if !non_null && rng.rand < @null_chance
+
+      core_value(type, node)
+    end
+  end
+
+  def core_value(type, node)
+    case type.kind.name
+    when "SCALAR"
+      @values.scalar(type.graphql_name, node.name)
+    when "ENUM"
+      type.values.keys.sort.sample(random: rng)
+    when "OBJECT"
+      object_value(type, node.selections)
+    when "UNION", "INTERFACE"
+      member = @schema.possible_types(type).sort_by(&:graphql_name).sample(random: rng)
+      object_value(member, node.selections)
+    else
+      raise NotImplementedError, "cannot fake kind: #{type.kind.name}"
+    end
+  end
+end

data/lib/graph_weaver/testing/values.rb

@@ -0,0 +1,98 @@
+# typed: true
+# frozen_string_literal: true
+
+require "date"
+
+# The value engine behind FakeClient and Cassette#anonymize!: seeded,
+# type-correct scalar generation with optional faker-backed semantics
+# matched on field names — strings (name/email/url/...) and numbers
+# (age/price/count/latitude/...) alike. Keeps a consistent id mapping so
+# the same original id always anonymizes to the same fake id.
+class GraphWeaver::Testing::Values
+  include GraphWeaver::Inflect
+
+  STRING_SEMANTICS = {
+    /email/ => -> { ::Faker::Internet.email },
+    /(^|_)first_name$/ => -> { ::Faker::Name.first_name },
+    /(^|_)last_name$/ => -> { ::Faker::Name.last_name },
+    /(^|_)(full_)?name$/ => -> { ::Faker::Name.name },
+    /(^|_)(url|website|link)$/ => -> { ::Faker::Internet.url },
+    /phone/ => -> { ::Faker::PhoneNumber.phone_number },
+    /(^|_)address$/ => -> { ::Faker::Address.full_address },
+    /(^|_)(city)$/ => -> { ::Faker::Address.city },
+    /(^|_)(title|description)$/ => -> { ::Faker::Lorem.sentence(word_count: 3) },
+  }.freeze
+
+  NUMBER_SEMANTICS = {
+    /(^|_)age$/ => ->(rng) { rng.rand(1..99) },
+    /(^|_)(price|amount|cost|total)(_cents)?$/ => ->(rng) { (rng.rand(1.0..10_000.0) * 100).round / 100.0 },
+    /(^|_)(count|quantity|size)$/ => ->(rng) { rng.rand(0..100) },
+    /latitude/ => ->(rng) { rng.rand(-90.0..90.0).round(6) },
+    /longitude/ => ->(rng) { rng.rand(-180.0..180.0).round(6) },
+    /(^|_)year$/ => ->(rng) { rng.rand(1970..2030) },
+  }.freeze
+
+  attr_reader :rng
+
+  def initialize(seed: nil, mode: nil)
+    config = GraphWeaver::Testing.config
+    @rng = Random.new(seed || config.seed || Random.new_seed)
+    @mode = resolve_mode(mode || config.mode)
+    @sequence = 0
+    @id_map = {}
+  end
+
+  def scalar(type_name, field_name)
+    prop = underscore(field_name)
+
+    if @mode == :faker
+      # rebind per call: several Values instances may interleave (e.g. two
+      # seeded fakes), and faker's rng is global
+      ::Faker::Config.random = @rng
+      case type_name
+      when "String"
+        STRING_SEMANTICS.each { |pattern, faker| return faker.call if pattern.match?(prop) }
+      when "Int", "Float"
+        NUMBER_SEMANTICS.each do |pattern, gen|
+          next unless pattern.match?(prop)
+
+          value = gen.call(@rng)
+          return type_name == "Int" ? value.to_i : value.to_f
+        end
+      end
+    end
+
+    case type_name
+    when "ID" then (@sequence += 1).to_s
+    when "String" then "#{field_name}-#{@sequence += 1}"
+    when "Int" then @rng.rand(0..1_000)
+    when "Float" then @rng.rand(0.0..1_000.0).round(2)
+    when "Boolean" then [true, false].sample(random: @rng)
+    when "Date" then (Date.new(2020, 1, 1) + @rng.rand(0..2_000)).iso8601
+    when "DateTime", "Time", "ISO8601DateTime" then Time.at(1_600_000_000 + @rng.rand(0..100_000_000)).utc.iso8601
+    else "#{type_name}-#{@sequence += 1}" # unknown custom scalar: override it
+    end
+  end
+
+  # same original id => same fake id, so relationships survive anonymization
+  def mapped_id(original)
+    @id_map[original] ||= (@sequence += 1).to_s
+  end
+
+  private
+
+  # :faker is an explicit ask — fail loudly when the gem is missing; auto
+  # (nil) quietly falls back to :literal
+  def resolve_mode(mode)
+    case mode
+    when :faker
+      raise ArgumentError, "mode: :faker requires the faker gem (add it to your Gemfile's test group)" unless defined?(::Faker)
+
+      :faker
+    when :literal then :literal
+    when nil then defined?(::Faker) ? :faker : :literal
+    else
+      raise ArgumentError, "mode: must be one of #{GraphWeaver::Testing::MODES.inspect} (or nil for auto), got #{mode.inspect}"
+    end
+  end
+end

data/lib/graph_weaver/testing.rb

@@ -0,0 +1,106 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "../graph_weaver"
+
+# faker is optional — semantic values (name/email/age/price/...) when
+# present, type-based values when not
+begin
+  require "faker"
+rescue LoadError
+  # fall back to type-based generation
+end
+
+# Opt-in test tooling: require "graph_weaver/testing" from your spec
+# helper (never from production code). Configure once, initializer-style:
+#
+#      GraphWeaver::Testing.configure do |config|
+#        config.schema = MySchema                  # for auto_fake / cassettes
+#        config.seed = 42                          # reproducible fakes
+#        config.mode = :faker                      # or :literal; nil = auto
+#        config.overrides = { "Person.name" => "Daniel" }
+#        config.list_size = 2..4
+#        config.null_chance = 0.1                  # nullable fields go nil sometimes
+#        config.cassette_dir = "spec/cassettes"
+#      end
+#
+# mode picks how values are fabricated:
+#      :faker   — semantic, field-name matched (requires the faker gem)
+#      :literal — plain type-derived values ("name-1", seeded numbers)
+#      nil      — auto: :faker when the gem is loaded, else :literal
+#
+# rspec users: require "graph_weaver/rspec" instead — it hooks the suite
+# (seed from rspec, optional auto-faked client per example).
+module GraphWeaver
+  module Testing
+    MODES = [:faker, :literal].freeze
+
+    class Config
+      attr_accessor :overrides, :seed, :list_size, :null_chance, :cassette_dir, :auto_fake,
+        :record, :anonymize
+      attr_writer :schema
+      attr_reader :mode
+
+      def initialize
+        @overrides = {}
+        @seed = nil
+        @list_size = 1..3
+        @null_chance = 0.0
+        @mode = nil # auto
+        @schema = nil
+        @cassette_dir = "spec/cassettes"
+        # on by default — engages only when a schema resolves (below), so
+        # requiring graph_weaver/rspec in a conventional app is
+        # zero-config; config.auto_fake = false opts out
+        @auto_fake = true
+        # GRAPHWEAVER_RECORD=1 rspec ...  -> Cassette.use re-records
+        @record = !ENV["GRAPHWEAVER_RECORD"].to_s.empty?
+        # anonymize responses as they're recorded (needs config.schema)
+        @anonymize = false
+      end
+
+      # the explicitly configured schema, else the conventional dump
+      # (SchemaLoader.locate at GraphWeaver.schema_path) — nil when
+      # neither exists, which quietly disables auto_fake
+      def schema
+        @schema ||= GraphWeaver::SchemaLoader.locate
+      end
+
+      def mode=(mode)
+        unless mode.nil? || MODES.include?(mode)
+          raise ArgumentError, "mode: must be one of #{MODES.inspect} (or nil for auto), got #{mode.inspect}"
+        end
+
+        @mode = mode
+      end
+    end
+
+    class << self
+      def config
+        @config ||= Config.new
+      end
+
+      def configure
+        yield config
+      end
+
+      # back to defaults — between tests, or to undo an experiment
+      def reset!
+        @config = nil
+      end
+
+      # resolve a cassette name ("github") against cassette_dir; paths
+      # with separators or extensions pass through
+      def cassette_path(name)
+        return name if name.include?("/") || name.end_with?(".yml", ".yaml")
+
+        File.join(config.cassette_dir, "#{name}.yml")
+      end
+    end
+  end
+end
+
+require_relative "testing/values"
+require_relative "testing/fake_client"
+require_relative "testing/failure"
+require_relative "testing/cassette"

data/lib/graph_weaver/transport/faraday.rb

@@ -0,0 +1,56 @@
+# typed: true
+# frozen_string_literal: true
+
+require "faraday"
+
+require_relative "../transport"
+
+module GraphWeaver
+  class Transport
+    # Faraday-backed transport. Opt-in (faraday is not a hard dependency):
+    #
+    #      require "graph_weaver/transport/faraday"
+    #
+    #      # simplest: build a default connection from a url
+    #      GraphWeaver::Transport::Faraday.new("https://api.example.com/graphql")
+    #
+    #      # customize middleware while building
+    #      GraphWeaver::Transport::Faraday.new(url) do |conn|
+    #        conn.request :authorization, "Bearer", -> { Tokens.fetch }
+    #        conn.response :logger
+    #      end
+    #
+    #      # or bring a fully configured connection
+    #      GraphWeaver::Transport::Faraday.new(Faraday.new(url:) { |conn| ... })
+    class Faraday < Transport
+      # Faraday's network-level failures — added to the shared, extensible
+      # transport-error set.
+      GraphWeaver.register_transport_error(
+        ::Faraday::ConnectionFailed, ::Faraday::TimeoutError, ::Faraday::SSLError
+      )
+
+      def initialize(url_or_connection, headers: {}, &block)
+        @connection = case url_or_connection
+        when ::Faraday::Connection
+          url_or_connection
+        else
+          # Faraday appends the default adapter when the block doesn't set one
+          ::Faraday.new(url: url_or_connection, headers:, &block)
+        end
+        @url = @connection.url_prefix.to_s
+      end
+
+      private
+
+      sig { override.params(body: String).returns([Integer, T.untyped]) }
+      def post(body)
+        response = @connection.post do |request|
+          request.headers["Content-Type"] = "application/json"
+          request.body = body
+        end
+
+        [response.status, response.body]
+      end
+    end
+  end
+end

data/lib/graph_weaver/transport/http.rb

@@ -0,0 +1,87 @@
+# typed: true
+# frozen_string_literal: true
+
+require "net/http"
+require "openssl"
+require "uri"
+
+require_relative "../transport"
+
+module GraphWeaver
+  class Transport
+    # Minimal net/http transport — zero dependencies, loaded by default:
+    #
+    #      GraphWeaver::Transport::HTTP.new(url, headers: { ... }, read_timeout: 10)
+    #
+    # Timeouts surface as TransportError (retriable). The connection is
+    # persistent (keep-alive), serialized behind a mutex — one socket per
+    # transport, dropped on any failure so the next call starts fresh.
+    # For real connection pooling and a middleware ecosystem, use
+    # Transport::Faraday.
+    class HTTP < Transport
+      # net/http's own network-level failures (Errno/SocketError/IOError
+      # are already seeded) — added to the shared, extensible
+      # transport-error set.
+      GraphWeaver.register_transport_error(Timeout::Error, OpenSSL::SSL::SSLError)
+
+      def initialize(url, headers: {}, open_timeout: 10, read_timeout: 30, keep_alive_timeout: 2)
+        @url = url
+        @uri = URI(url)
+        @headers = headers
+        @open_timeout = open_timeout
+        @read_timeout = read_timeout
+        @keep_alive_timeout = keep_alive_timeout
+        @mutex = Mutex.new
+        @http = T.let(nil, T.nilable(Net::HTTP))
+      end
+
+      private
+
+      sig { override.params(body: String).returns([Integer, T.untyped]) }
+      def post(body)
+        request = Net::HTTP::Post.new(@uri, { "Content-Type" => "application/json" }.merge(@headers))
+        request.body = body
+
+        response = @mutex.synchronize do
+          begin
+            connection.request(request)
+          rescue => e
+            # socket state is unknown — drop it so the next call starts
+            # fresh (retry policy belongs to Retry, not here)
+            disconnect
+            raise e
+          end
+        end
+
+        [response.code.to_i, response.body]
+      end
+
+      # The persistent connection. net/http proactively reconnects when
+      # idle past keep_alive_timeout, so a server-closed keep-alive
+      # socket doesn't produce spurious failures.
+      def connection
+        @http ||= begin
+          GraphWeaver.log(:debug) { "connecting to #{@uri.hostname}:#{@uri.port}" }
+          Net::HTTP.start(
+            @uri.hostname, @uri.port,
+            use_ssl: @uri.scheme == "https",
+            open_timeout: @open_timeout, read_timeout: @read_timeout,
+            keep_alive_timeout: @keep_alive_timeout,
+          )
+        end
+      end
+
+      def disconnect
+        http = @http
+        return unless http
+
+        GraphWeaver.log(:debug) { "dropping connection to #{@uri.hostname}:#{@uri.port}" }
+        http.finish if http.started?
+      rescue IOError
+        # already closed
+      ensure
+        @http = nil
+      end
+    end
+  end
+end