iron_admin 0.4.1 → 0.6.0

data/vendor/bundle/ruby/3.2.0/gems/webmock-3.26.2/lib/webmock/request_stub.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module WebMock
+  class RequestStub
+
+    attr_accessor :request_pattern
+
+    def initialize(method, uri)
+      @request_pattern = RequestPattern.new(method, uri)
+      @responses_sequences = []
+      self
+    end
+
+    def with(params = {}, &block)
+      @request_pattern.with(params, &block)
+      self
+    end
+
+    def to_return(*response_hashes, &block)
+      if block
+        @responses_sequences << ResponsesSequence.new([ResponseFactory.response_for(block)])
+      else
+        @responses_sequences << ResponsesSequence.new([*response_hashes].flatten.map {|r| ResponseFactory.response_for(r)})
+      end
+      self
+    end
+    alias_method :and_return, :to_return
+
+    def to_return_json(*response_hashes)
+      raise ArgumentError, '#to_return_json does not support passing a block' if block_given?
+
+      json_response_hashes = [*response_hashes].flatten.map do |resp_h|
+        headers, body = resp_h.values_at(:headers, :body)
+
+        json_body = if body.respond_to?(:call)
+          ->(request_signature) {
+            b = if body.respond_to?(:arity) && body.arity == 1
+              body.call(request_signature)
+            else
+              body.call
+            end
+            b = b.to_json unless b.is_a?(String)
+            b
+          }
+        elsif !body.is_a?(String)
+          body.to_json
+        else
+          body
+        end
+
+        resp_h.merge(
+          headers: {content_type: 'application/json'}.merge(headers.to_h),
+          body: json_body
+        )
+      end
+
+      to_return(json_response_hashes)
+    end
+    alias_method :and_return_json, :to_return_json
+
+    def to_rack(app, options={})
+      @responses_sequences << ResponsesSequence.new([RackResponse.new(app)])
+    end
+
+    def to_raise(*exceptions)
+      @responses_sequences << ResponsesSequence.new([*exceptions].flatten.map {|e|
+        ResponseFactory.response_for(exception: e)
+      })
+      self
+    end
+    alias_method :and_raise, :to_raise
+
+    def to_timeout
+      @responses_sequences << ResponsesSequence.new([ResponseFactory.response_for(should_timeout: true)])
+      self
+    end
+    alias_method :and_timeout, :to_timeout
+
+    def response
+      if @responses_sequences.empty?
+        WebMock::Response.new
+      elsif @responses_sequences.length > 1
+        @responses_sequences.shift if @responses_sequences.first.end?
+        @responses_sequences.first.next_response
+      else
+        @responses_sequences[0].next_response
+      end
+    end
+
+    def has_responses?
+      !@responses_sequences.empty?
+    end
+
+    def then
+      self
+    end
+
+    def times(number)
+      raise "times(N) accepts integers >= 1 only" if !number.is_a?(Integer) || number < 1
+      if @responses_sequences.empty?
+        raise "Invalid WebMock stub declaration." +
+          " times(N) can be declared only after response declaration."
+      end
+      @responses_sequences.last.times_to_repeat += number-1
+      self
+    end
+
+    def matches?(request_signature)
+      self.request_pattern.matches?(request_signature)
+    end
+
+    def to_s
+      self.request_pattern.to_s
+    end
+
+    def self.from_request_signature(signature)
+      stub = self.new(signature.method.to_sym, signature.uri.to_s)
+
+      if signature.body.to_s != ''
+        body = if signature.url_encoded?
+          WebMock::Util::QueryMapper.query_to_values(signature.body, notation: Config.instance.query_values_notation)
+        else
+          signature.body
+        end
+        stub.with(body: body)
+      end
+
+      if (signature.headers && !signature.headers.empty?)
+        stub.with(headers: signature.headers)
+      end
+      stub
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/webmock-3.26.2/lib/webmock/response.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module WebMock
+
+  class ResponseFactory
+    def self.response_for(options)
+      if options.respond_to?(:call)
+        WebMock::DynamicResponse.new(options)
+      else
+        WebMock::Response.new(options)
+      end
+    end
+  end
+
+  class Response
+    def initialize(options = {})
+      case options
+      when IO, StringIO
+        self.options = read_raw_response(options)
+      when String
+        self.options = read_raw_response(StringIO.new(options))
+      else
+        self.options = options
+      end
+    end
+
+    def headers
+      @headers
+    end
+
+    def headers=(headers)
+      @headers = headers
+      if @headers && !@headers.is_a?(Proc)
+        @headers = Util::Headers.normalize_headers(@headers)
+      end
+    end
+
+    def body
+      @body || String.new("")
+    end
+
+    def body=(body)
+      @body = body
+      assert_valid_body!
+      stringify_body!
+    end
+
+    def status
+      @status || [200, ""]
+    end
+
+    def status=(status)
+      @status = status.is_a?(Integer) ? [status, ""] : status
+    end
+
+    def exception
+      @exception
+    end
+
+    def exception=(exception)
+      @exception = case exception
+      when String then StandardError.new(exception)
+      when Class then exception.new('Exception from WebMock')
+      when Exception then exception
+      end
+    end
+
+    def raise_error_if_any
+      raise @exception if @exception
+    end
+
+    def should_timeout
+      @should_timeout == true
+    end
+
+    def options=(options)
+      options = WebMock::Util::HashKeysStringifier.stringify_keys!(options)
+      HashValidator.new(options).validate_keys('headers', 'status', 'body', 'exception', 'should_timeout')
+      self.headers = options['headers']
+      self.status = options['status']
+      self.body = options['body']
+      self.exception = options['exception']
+      @should_timeout = options['should_timeout']
+    end
+
+    def evaluate(request_signature)
+      self.body = @body.call(request_signature) if @body.is_a?(Proc)
+      self.headers = @headers.call(request_signature) if @headers.is_a?(Proc)
+      self.status = @status.call(request_signature) if @status.is_a?(Proc)
+      @should_timeout = @should_timeout.call(request_signature) if @should_timeout.is_a?(Proc)
+      @exception = @exception.call(request_signature) if @exception.is_a?(Proc)
+      self
+    end
+
+    def ==(other)
+      self.body == other.body &&
+        self.headers === other.headers &&
+        self.status == other.status &&
+        self.exception == other.exception &&
+        self.should_timeout == other.should_timeout
+    end
+
+    private
+
+    def stringify_body!
+      if @body.is_a?(IO) || @body.is_a?(Pathname)
+        io = @body
+        @body = io.read
+        io.close if io.respond_to?(:close)
+      end
+    end
+
+    def assert_valid_body!
+      valid_types = [Proc, IO, Pathname, String, Array]
+      return if @body.nil?
+      return if valid_types.any? { |c| @body.is_a?(c) }
+
+      if @body.is_a?(Hash)
+        raise InvalidBody, "must be one of: #{valid_types}, but you've used a #{@body.class}. " \
+          "Please convert it by calling .to_json .to_xml, or otherwise convert it to a string."
+      else
+        raise InvalidBody, "must be one of: #{valid_types}. '#{@body.class}' given."
+      end
+    end
+
+    def read_raw_response(io)
+      socket = ::Net::BufferedIO.new(io)
+      response = ::Net::HTTPResponse.read_new(socket)
+      transfer_encoding = response.delete('transfer-encoding') #chunks were already read by curl
+      response.reading_body(socket, true) {}
+
+      options = {}
+      options[:headers] = {}
+      response.each_header {|name, value| options[:headers][name] = value}
+      options[:headers]['transfer-encoding'] = transfer_encoding if transfer_encoding
+      options[:body] = response.read_body
+      options[:status] = [response.code.to_i, response.message]
+      options
+    ensure
+      socket.close
+    end
+
+    InvalidBody = Class.new(StandardError)
+
+  end
+
+  class DynamicResponse < Response
+    attr_accessor :responder
+
+    def initialize(responder)
+      @responder = responder
+    end
+
+    def evaluate(request_signature)
+      options = @responder.call(request_signature)
+      Response.new(options)
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/webmock-3.26.2/lib/webmock/responses_sequence.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module WebMock
+
+  class ResponsesSequence
+
+    attr_accessor :times_to_repeat
+
+    def initialize(responses)
+      @times_to_repeat = 1
+      @responses = responses
+      @current_position = 0
+    end
+
+    def end?
+      @times_to_repeat == 0
+    end
+
+    def next_response
+      if @times_to_repeat > 0
+        response = @responses[@current_position]
+        increase_position
+        response
+      else
+        @responses.last
+      end
+    end
+
+    private
+
+    def increase_position
+      if @current_position == (@responses.length - 1)
+        @current_position = 0
+        @times_to_repeat -= 1
+      else
+        @current_position += 1
+      end
+    end
+
+  end
+
+end

data/vendor/bundle/ruby/3.2.0/gems/webmock-3.26.2/lib/webmock/rspec/matchers/request_pattern_matcher.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module WebMock
+  class RequestPatternMatcher
+
+    def initialize
+      @request_execution_verifier = RequestExecutionVerifier.new
+    end
+
+    def once
+      @request_execution_verifier.expected_times_executed = 1
+      self
+    end
+
+    def twice
+      @request_execution_verifier.expected_times_executed = 2
+      self
+    end
+
+    def times(times)
+      @request_execution_verifier.expected_times_executed = times.to_i
+      self
+    end
+
+    def at_least_once
+      @request_execution_verifier.at_least_times_executed = 1
+      self
+    end
+
+    def at_least_twice
+      @request_execution_verifier.at_least_times_executed = 2
+      self
+    end
+
+    def at_least_times(times)
+      @request_execution_verifier.at_least_times_executed = times.to_i
+      self
+    end
+
+    def at_most_once
+      @request_execution_verifier.at_most_times_executed = 1
+      self
+    end
+
+    def at_most_twice
+      @request_execution_verifier.at_most_times_executed = 2
+      self
+    end
+
+    def at_most_times(times)
+      @request_execution_verifier.at_most_times_executed = times.to_i
+      self
+    end
+
+    def matches?(request_pattern)
+      @request_execution_verifier.request_pattern = request_pattern
+      @request_execution_verifier.matches?
+    end
+
+    def does_not_match?(request_pattern)
+      @request_execution_verifier.request_pattern = request_pattern
+      @request_execution_verifier.does_not_match?
+    end
+
+    def failure_message
+      @request_execution_verifier.failure_message
+    end
+
+    def failure_message_when_negated
+      @request_execution_verifier.failure_message_when_negated
+    end
+
+    def description
+      @request_execution_verifier.description
+    end
+
+    # RSpec 2 compatibility:
+    alias_method :negative_failure_message, :failure_message_when_negated
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/webmock-3.26.2/lib/webmock/rspec/matchers/webmock_matcher.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module WebMock
+  class WebMockMatcher
+
+    def initialize(method, uri)
+      @request_execution_verifier = RequestExecutionVerifier.new
+      @request_execution_verifier.request_pattern = RequestPattern.new(method, uri)
+    end
+
+    def once
+      @request_execution_verifier.expected_times_executed = 1
+      self
+    end
+
+    def twice
+      @request_execution_verifier.expected_times_executed = 2
+      self
+    end
+
+    def at_least_once
+      @request_execution_verifier.at_least_times_executed = 1
+      self
+    end
+
+    def at_least_twice
+      @request_execution_verifier.at_least_times_executed = 2
+      self
+    end
+
+    def at_least_times(times)
+      @request_execution_verifier.at_least_times_executed = times
+      self
+    end
+
+    def with(options = {}, &block)
+      @request_execution_verifier.request_pattern.with(options, &block)
+      self
+    end
+
+    def times(times)
+      @request_execution_verifier.expected_times_executed = times.to_i
+      self
+    end
+
+    def matches?(webmock)
+      @request_execution_verifier.matches?
+    end
+
+    def does_not_match?(webmock)
+      @request_execution_verifier.does_not_match?
+    end
+
+    def failure_message
+      @request_execution_verifier.failure_message
+    end
+
+    def failure_message_when_negated
+      @request_execution_verifier.failure_message_when_negated
+    end
+
+    def description
+      @request_execution_verifier.description
+    end
+
+    # RSpec 2 compatibility:
+    alias_method :negative_failure_message, :failure_message_when_negated
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/webmock-3.26.2/lib/webmock/rspec/matchers.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'webmock'
+require 'webmock/rspec/matchers/request_pattern_matcher'
+require 'webmock/rspec/matchers/webmock_matcher'
+
+module WebMock
+  module Matchers
+    def have_been_made
+      WebMock::RequestPatternMatcher.new
+    end
+
+    def have_been_requested
+      WebMock::RequestPatternMatcher.new
+    end
+
+    def have_not_been_made
+      WebMock::RequestPatternMatcher.new.times(0)
+    end
+
+    def have_requested(method, uri)
+      WebMock::WebMockMatcher.new(method, uri)
+    end
+
+    def have_not_requested(method, uri)
+      WebMock::WebMockMatcher.new(method, uri).times(0)
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/webmock-3.26.2/lib/webmock/rspec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'webmock'
+
+# RSpec 1.x and 2.x compatibility
+if defined?(RSpec::Expectations::ExpectationNotMetError)
+  RSPEC_NAMESPACE = RSPEC_CONFIGURER = RSpec
+elsif defined?(Spec) && defined?(Spec.configure)
+  RSPEC_NAMESPACE = Spec
+  RSPEC_CONFIGURER = Spec::Runner
+else
+  begin
+    require 'rspec/core'
+    require 'rspec/expectations'
+    RSPEC_NAMESPACE = RSPEC_CONFIGURER = RSpec
+  rescue LoadError
+    require 'spec'
+    RSPEC_NAMESPACE = Spec
+    RSPEC_CONFIGURER = Spec::Runner
+  end
+end
+
+require 'webmock/rspec/matchers'
+
+RSPEC_CONFIGURER.configure { |config|
+
+  config.include WebMock::API
+  config.include WebMock::Matchers
+
+  config.before(:suite) do
+    WebMock.enable!
+  end
+
+  config.after(:suite) do
+    WebMock.disable!
+  end
+
+  config.around(:each) do |example|
+    example.run
+    WebMock.reset!
+  end
+}
+
+WebMock::AssertionFailure.error_class = RSPEC_NAMESPACE::Expectations::ExpectationNotMetError

data/vendor/bundle/ruby/3.2.0/gems/webmock-3.26.2/lib/webmock/stub_registry.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module WebMock
+
+  class StubRegistry
+    include Singleton
+
+    attr_accessor :request_stubs
+
+    def initialize
+      reset!
+    end
+
+    def global_stubs
+      @global_stubs ||= Hash.new { |h, k| h[k] = [] }
+    end
+
+    def reset!
+      self.request_stubs = []
+    end
+
+    def register_global_stub(order = :before_local_stubs, &block)
+      unless %i[before_local_stubs after_local_stubs].include?(order)
+        raise ArgumentError.new("Wrong order. Use :before_local_stubs or :after_local_stubs")
+      end
+
+      # This hash contains the responses returned by the block,
+      # keyed by the exact request (using the object_id).
+      # That way, there's no race condition in case #to_return
+      # doesn't run immediately after stub.with.
+      responses = {}
+      response_lock = Mutex.new
+
+      stub = ::WebMock::RequestStub.new(:any, ->(uri) { true }).with { |request|
+        update_response = -> { responses[request.object_id] = yield(request) }
+
+        # The block can recurse, so only lock if we don't already own it
+        if response_lock.owned?
+          update_response.call
+        else
+          response_lock.synchronize(&update_response)
+        end
+      }.to_return(lambda { |request|
+        response_lock.synchronize { responses.delete(request.object_id) }
+      })
+
+      global_stubs[order].push stub
+    end
+
+    def register_request_stub(stub)
+      request_stubs.insert(0, stub)
+      stub
+    end
+
+    def remove_request_stub(stub)
+      if not request_stubs.delete(stub)
+        raise "Request stub \n\n #{stub.to_s} \n\n is not registered."
+      end
+    end
+
+    def registered_request?(request_signature)
+      request_stub_for(request_signature)
+    end
+
+    def response_for_request(request_signature)
+      stub = request_stub_for(request_signature)
+      stub ? evaluate_response_for_request(stub.response, request_signature) : nil
+    end
+
+    private
+
+    def request_stub_for(request_signature)
+      (global_stubs[:before_local_stubs] + request_stubs + global_stubs[:after_local_stubs])
+        .detect { |registered_request_stub|
+          registered_request_stub.request_pattern.matches?(request_signature)
+        }
+    end
+
+    def evaluate_response_for_request(response, request_signature)
+      response.dup.evaluate(request_signature)
+    end
+
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/webmock-3.26.2/lib/webmock/stub_request_snippet.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module WebMock
+  class StubRequestSnippet
+    def initialize(request_stub)
+      @request_stub = request_stub
+    end
+
+    def body_pattern
+      request_pattern.body_pattern
+    end
+
+    def to_s(with_response = true)
+      request_pattern = @request_stub.request_pattern
+      string = "stub_request(:#{request_pattern.method_pattern.to_s},".dup
+      string << " \"#{request_pattern.uri_pattern.to_s}\")"
+
+      with = "".dup
+
+      if (request_pattern.body_pattern)
+        with << "\n    body: #{request_pattern.body_pattern.to_s}"
+      end
+
+      if (request_pattern.headers_pattern)
+        with << "," unless with.empty?
+
+        with << "\n    headers: #{request_pattern.headers_pattern.pp_to_s}"
+      end
+      string << ".\n  with(#{with})" unless with.empty?
+      if with_response
+        if request_pattern.headers_pattern && request_pattern.headers_pattern.matches?({ 'Accept' => "application/json" })
+          string << ".\n  to_return(status: 200, body: \"{}\", headers: {})"
+        else
+          string << ".\n  to_return(status: 200, body: \"\", headers: {})"
+        end
+      end
+      string
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/webmock-3.26.2/lib/webmock/test_unit.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'test/unit'
+require 'webmock'
+
+WebMock.enable!
+
+module Test
+  module Unit
+    class TestCase
+      include WebMock::API
+
+      teardown
+      def teardown_with_webmock
+        WebMock.reset!
+      end
+
+    end
+  end
+end
+
+WebMock::AssertionFailure.error_class = Test::Unit::AssertionFailedError