ory-client 1.21.6 → 1.22.1

data/vendor/bundle/ruby/3.1.0/gems/ethon-0.15.0/profile/support/memory_test_helpers.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+require_relative 'ruby_object_leak_tracker'
+require_relative 'os_memory_leak_tracker'
+
+module MemoryTestHelpers
+  class << self
+    attr_accessor :gc_proc, :iterations, :logger
+
+    def setup
+      if RUBY_PLATFORM == "java"
+        # for leak detection
+        JRuby.objectspace = true if defined?(JRuby)
+        # for gc
+        require 'java'
+        java_import 'java.lang.System'
+        self.gc_proc = proc { System.gc }
+      else
+        self.gc_proc = proc { GC.start }
+      end
+    end
+  end
+
+  module TestMethods
+    def memory_leak_test(description, &block)
+      context(description) do
+        it "doesn't leak ruby objects" do
+          object_leak_tracker = RubyObjectLeakTracker.new
+          track_memory_usage(object_leak_tracker, &block)
+          object_leak_tracker.total_difference_between_runs.should be <= 10
+        end
+
+        it "doesn't leak OS memory (C interop check)" do
+          os_memory_leak_tracker = OSMemoryLeakTracker.new
+          track_memory_usage(os_memory_leak_tracker, &block)
+          os_memory_leak_tracker.total_difference_between_runs.should be <= 10
+        end
+      end
+    end
+  end
+
+  def track_memory_usage(tracker)
+    # Intentionally do all this setup before we do any testing
+    logger = MemoryTestHelpers.logger
+    iterations = MemoryTestHelpers.iterations
+
+    checkpoint_frequency = (iterations / 10.0).to_i
+    gc_frequency = 20
+
+    warmup_iterations = [(iterations / 3.0).to_i, 500].min
+    logger.info "Performing #{warmup_iterations} warmup iterations"
+    warmup_iterations.times do
+      yield
+      MemoryTestHelpers.gc_proc.call
+    end
+    tracker.capture_initial_memory_usage
+
+    logger.info "Performing #{iterations} iterations (checkpoint every #{checkpoint_frequency})"
+
+    iterations.times do |i|
+      yield
+
+      last_iteration = (i == iterations - 1)
+      checkpoint = last_iteration || (i % checkpoint_frequency == 0)
+
+      if checkpoint || (i % gc_frequency == 0)
+        MemoryTestHelpers.gc_proc.call
+      end
+
+      if checkpoint
+        logger.info "Iteration #{i} checkpoint"
+        tracker.capture_memory_usage
+        tracker.dump_status(logger)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/ethon-0.15.0/profile/support/os_memory_leak_tracker.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+class OSMemoryLeakTracker
+  attr_reader :current_run
+
+  def initialize
+    @previous_run = @current_run = 0
+  end
+
+  def difference_between_runs(basis=@previous_run)
+    @current_run - basis
+  end
+
+  def total_difference_between_runs
+    difference_between_runs(@initial_count_run)
+  end
+
+  def capture_initial_memory_usage
+    capture_memory_usage
+    @initial_count_run = @current_run
+  end
+
+  def capture_memory_usage
+    @previous_run = @current_run
+    @current_run = rss_bytes
+  end
+
+  def dump_status(logger)
+    delta = difference_between_runs
+    logger.add(log_level(delta), sprintf("\tTotal memory usage (kb): %d (%+d)", current_run, delta))
+  end
+
+  private
+  # amount of memory the current process "is using", in RAM
+  # (doesn't include any swap memory that it may be using, just that in actual RAM)
+  # Code loosely based on https://github.com/rdp/os/blob/master/lib/os.rb
+  # returns 0 on windows
+  def rss_bytes
+    if ENV['OS'] == 'Windows_NT'
+      0
+    else
+      `ps -o rss= -p #{Process.pid}`.to_i # in kilobytes
+    end
+  end
+
+  def log_level(delta)
+    delta > 0 ? Logger::WARN : Logger::DEBUG
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/ethon-0.15.0/profile/support/ruby_object_leak_tracker.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+class RubyObjectLeakTracker
+  attr_reader :previous_count_hash, :current_count_hash
+
+  def initialize
+    @previous_count_hash = @current_count_hash = {}    
+  end
+
+  def difference_between_runs(basis=@previous_count_hash)
+    @difference_between_runs ||= Hash[@current_count_hash.map do |object_class, count|
+      [object_class, count - (basis[object_class] || 0)]
+    end]
+  end
+
+  def total_difference_between_runs
+    difference_between_runs(@initial_count_hash).values.inject(0) { |sum, count| sum + count }
+  end
+
+  def capture_initial_memory_usage
+    capture_memory_usage
+    @initial_count_hash = @current_count_hash
+  end
+
+  def capture_memory_usage
+    @difference_between_runs = nil
+    @previous_count_hash = @current_count_hash
+
+    class_to_count = Hash.new { |hash, key| hash[key] = 0 }
+    ObjectSpace.each_object { |obj| class_to_count[obj.class] += 1 }
+
+    sorted_class_to_count = class_to_count.sort_by { |k, v| -v }
+    @current_count_hash = Hash[sorted_class_to_count]
+  end
+
+  def dump_status(logger)
+    diff = difference_between_runs
+    most_used_objects = current_count_hash.to_a.sort_by(&:last).reverse[0, 20]
+
+    most_used_objects.each do |object_class, count|
+      delta = diff[object_class]
+      logger.add(log_level(delta), sprintf("\t%s: %d (%+d)", object_class, count, delta))
+    end
+  end
+
+  private
+  def log_level(delta)
+    delta > 0 ? Logger::WARN : Logger::DEBUG
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/ethon-0.15.0/spec/ethon/curl_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Ethon::Curl do
+  describe ".init" do
+    before { Ethon::Curl.send(:class_variable_set, :@@initialized, false) }
+
+    context "when global_init fails" do
+      it "raises global init error" do
+        expect(Ethon::Curl).to receive(:global_init).and_return(1)
+        expect{ Ethon::Curl.init }.to raise_error(Ethon::Errors::GlobalInit)
+      end
+    end
+
+    context "when global_init works" do
+      before { expect(Ethon::Curl).to receive(:global_init).and_return(0) }
+
+      it "doesn't raises global init error" do
+        expect{ Ethon::Curl.init }.to_not raise_error
+      end
+
+      it "logs" do
+        expect(Ethon.logger).to receive(:debug)
+        Ethon::Curl.init
+      end
+    end
+
+    context "when global_cleanup is called" do
+      before { expect(Ethon::Curl).to receive(:global_cleanup) }
+
+      it "logs" do
+        expect(Ethon.logger).to receive(:debug).twice
+        Ethon::Curl.init
+        Ethon::Curl.cleanup
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/ethon-0.15.0/spec/ethon/easy/callbacks_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Ethon::Easy::Callbacks do
+  let!(:easy) { Ethon::Easy.new }
+
+  describe "#set_callbacks" do
+    before do
+      expect(Ethon::Curl).to receive(:set_option).exactly(3).times
+    end
+
+    it "sets write-, debug-, and headerfunction" do
+      easy.set_callbacks
+    end
+
+    it "resets @response_body" do
+      easy.set_callbacks
+      expect(easy.instance_variable_get(:@response_body)).to eq("")
+    end
+
+    it "resets @response_headers" do
+      easy.set_callbacks
+      expect(easy.instance_variable_get(:@response_headers)).to eq("")
+    end
+
+    it "resets @debug_info" do
+      easy.set_callbacks
+      expect(easy.instance_variable_get(:@debug_info).to_a).to eq([])
+    end
+  end
+
+  describe "#progress_callback" do
+    it "returns 0" do
+      expect(easy.progress_callback.call(0,1,1,1,1)).to be(0)
+    end
+  end
+
+  describe "#body_write_callback" do
+    let(:body_write_callback) { easy.instance_variable_get(:@body_write_callback) }
+    let(:stream) { double(:read_string => "") }
+    context "when body returns not :abort" do
+      it "returns number bigger than 0" do
+        expect(body_write_callback.call(stream, 1, 1, nil) > 0).to be(true)
+      end
+    end
+
+    context "when body returns :abort" do
+      before do
+        easy.on_body.clear
+        easy.on_body { :abort }
+      end
+      let(:body_write_callback) { easy.instance_variable_get(:@body_write_callback) }
+
+      it "returns -1 to indicate abort to libcurl" do
+        expect(body_write_callback.call(stream, 1, 1, nil)).to eq(-1)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/ethon-0.15.0/spec/ethon/easy/debug_info_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Ethon::Easy::DebugInfo do
+  let(:easy) { Ethon::Easy.new }
+
+  before do
+    easy.url = "http://localhost:3001/"
+    easy.perform
+  end
+
+  describe "#debug_info" do
+    context "when verbose is not set to true" do
+      it "does not save any debug info after a request" do
+        expect(easy.debug_info.to_a.length).to eq(0)
+        expect(easy.debug_info.to_h.values.flatten.length).to eq(0)
+      end
+    end
+
+    context "when verbose is set to true" do
+      before do
+        easy.verbose = true
+        easy.perform
+      end
+
+      after do
+        easy.verbose = false
+        easy.reset
+      end
+
+      it "saves debug info after a request" do
+        expect(easy.debug_info.to_a.length).to be > 0
+      end
+
+      it "saves request headers" do
+        expect(easy.debug_info.header_out.join).to include('GET / HTTP/1.1')
+      end
+
+      it "saves response headers" do
+        expect(easy.debug_info.header_in.length).to be > 0
+        expect(easy.response_headers).to include(easy.debug_info.header_in.join)
+      end
+
+      it "saves incoming data" do
+        expect(easy.debug_info.data_in.length).to be > 0
+        expect(easy.response_body).to include(easy.debug_info.data_in.join)
+      end
+
+      it "saves debug text" do
+        expect(easy.debug_info.text.length).to be > 0
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/ethon-0.15.0/spec/ethon/easy/features_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Ethon::Easy::Informations do
+
+  describe "#supports_asynch_dns?" do
+    it "returns boolean" do
+      expect([true, false].include? Ethon::Easy.supports_asynch_dns?).to be_truthy
+    end
+  end
+
+  describe "#supports_zlib?" do
+    it "returns boolean" do
+      expect([true, false].include? Ethon::Easy.supports_zlib?).to be_truthy
+    end
+  end
+
+  describe "#supports_timeout_ms?" do
+    it "returns boolean" do
+      expect([true, false].include? Ethon::Easy.supports_timeout_ms?).to be_truthy
+    end
+  end
+
+end

data/vendor/bundle/ruby/3.1.0/gems/ethon-0.15.0/spec/ethon/easy/form_spec.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Ethon::Easy::Form do
+  let(:hash) { {} }
+  let!(:easy) { Ethon::Easy.new }
+  let(:form) { Ethon::Easy::Form.new(easy, hash) }
+
+  describe ".new" do
+    it "assigns attribute to @params" do
+      expect(form.instance_variable_get(:@params)).to eq(hash)
+    end
+  end
+
+  describe "#first" do
+    it "returns a pointer" do
+      expect(form.first).to be_a(FFI::Pointer)
+    end
+  end
+
+  describe "#last" do
+    it "returns a pointer" do
+      expect(form.first).to be_a(FFI::Pointer)
+    end
+  end
+
+  describe "#multipart?" do
+    before { form.instance_variable_set(:@query_pairs, pairs) }
+
+    context "when query_pairs contains string values" do
+      let(:pairs) { [['a', '1'], ['b', '2']] }
+
+      it "returns false" do
+        expect(form.multipart?).to be_falsey
+      end
+    end
+
+    context "when query_pairs contains file" do
+      let(:pairs) { [['a', '1'], ['b', ['path', 'encoding', 'abs_path']]] }
+
+      it "returns true" do
+        expect(form.multipart?).to be_truthy
+      end
+    end
+
+    context "when options contains multipart=true" do
+      before { form.instance_variable_set(:@multipart, true) }
+      let(:pairs) { [['a', '1'], ['b', '2']] }
+
+      it "returns true" do
+        expect(form.multipart?).to be_truthy
+      end
+    end
+  end
+
+  describe "#materialize" do
+    before { form.instance_variable_set(:@query_pairs, pairs) }
+
+    context "when query_pairs contains string values" do
+      let(:pairs) { [['a', '1']] }
+
+      it "adds params to form" do
+        expect(Ethon::Curl).to receive(:formadd)
+        form.materialize
+      end
+    end
+
+    context "when query_pairs contains nil" do
+      let(:pairs) { [['a', nil]] }
+
+      it "adds params to form" do
+        expect(Ethon::Curl).to receive(:formadd)
+        form.materialize
+      end
+    end
+
+    context "when query_pairs contains file" do
+      let(:pairs) { [['a', ["file", "type", "path/file"]]] }
+
+      it "adds file to form" do
+        expect(Ethon::Curl).to receive(:formadd)
+        form.materialize
+      end
+    end
+
+    context "when query_pairs contains file and string values" do
+      let(:pairs) { [['a', ["file", "type", "path/file"]], ['b', '1']] }
+
+      it "adds file to form" do
+        expect(Ethon::Curl).to receive(:formadd).twice
+        form.materialize
+      end
+    end
+
+    context "when query_pairs contains file, string and int values" do
+      let(:pairs) { [['a', ["file", "type", "path/file"]], ['b', '1'], ['c', 1]] }
+
+      it "adds file to form" do
+        expect(Ethon::Curl).to receive(:formadd).exactly(3).times
+        form.materialize
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.1.0/gems/ethon-0.15.0/spec/ethon/easy/header_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Ethon::Easy::Header do
+  let(:easy) { Ethon::Easy.new }
+
+  describe "#headers=" do
+    let(:headers) { { 'User-Agent' => 'Ethon' } }
+
+    it "sets header" do
+      expect_any_instance_of(Ethon::Easy).to receive(:set_callbacks)
+      expect(Ethon::Curl).to receive(:set_option)
+      easy.headers = headers
+    end
+
+    context "when requesting" do
+      before do
+        easy.headers = headers
+        easy.url = "http://localhost:3001"
+        easy.perform
+      end
+
+      it "sends" do
+        expect(easy.response_body).to include('"HTTP_USER_AGENT":"Ethon"')
+      end
+
+      context "when header value contains null byte" do
+        let(:headers) { { 'User-Agent' => "Ethon\0" } }
+
+        it "escapes" do
+          expect(easy.response_body).to include('"HTTP_USER_AGENT":"Ethon\\\\0"')
+        end
+      end
+
+      context "when header value has leading whitespace" do
+        let(:headers) { { 'User-Agent' => " Ethon" } }
+
+        it "removes" do
+          expect(easy.response_body).to include('"HTTP_USER_AGENT":"Ethon"')
+        end
+      end
+
+      context "when header value has traiing whitespace" do
+        let(:headers) { { 'User-Agent' => "Ethon " } }
+
+        it "removes" do
+          expect(easy.response_body).to include('"HTTP_USER_AGENT":"Ethon"')
+        end
+      end
+    end
+  end
+
+  describe "#compose_header" do
+    it "has space in between" do
+      expect(easy.compose_header('a', 'b')).to eq('a: b')
+    end
+
+    context "when value is a symbol" do
+      it "works" do
+        expect{ easy.compose_header('a', :b) }.to_not raise_error
+      end
+    end
+  end
+
+  describe "#header_list" do
+    context "when no set_headers" do
+      it "returns nil" do
+        expect(easy.header_list).to eq(nil)
+      end
+    end
+
+    context "when set_headers" do
+      it "returns pointer to header list" do
+        easy.headers = {'User-Agent' => 'Custom'}
+        expect(easy.header_list).to be_a(FFI::Pointer)
+      end
+    end
+  end
+end