talon_one 6.0.0 → 7.0.0

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/ethon-0.16.0/spec/ethon/easy/queryable_spec.rb

@@ -0,0 +1,235 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Ethon::Easy::Queryable do
+  let(:hash) { {} }
+  let!(:easy) { Ethon::Easy.new }
+  let(:params) { Ethon::Easy::Params.new(easy, hash) }
+
+  describe "#to_s" do
+    context "when query_pairs empty" do
+      before { params.instance_variable_set(:@query_pairs, []) }
+
+      it "returns empty string" do
+        expect(params.to_s).to eq("")
+      end
+    end
+
+    context "when query_pairs not empty" do
+      context "when escape" do
+        before do
+          params.escape = true
+        end
+
+        {
+          '!' => '%21', '*' => '%2A', "'" => '%27', '(' => '%28',
+          ')'  => '%29', ';' => '%3B', ':' => '%3A', '@' => '%40',
+          '&' => '%26', '=' => '%3D', '+' => '%2B', '$' => '%24',
+          ',' => '%2C', '/' => '%2F', '?' => '%3F', '#' => '%23',
+          '[' => '%5B', ']' => '%5D',
+
+          '<' => '%3C', '>' => '%3E', '"' => '%22', '{' => '%7B',
+          '}' => '%7D', '|' => '%7C', '\\' => '%5C', '`' => '%60',
+          '^' => '%5E', '%' => '%25', ' ' => '%20', "\0" => '%00',
+
+          'まつもと' => '%E3%81%BE%E3%81%A4%E3%82%82%E3%81%A8',
+        }.each do |value, percent|
+          it "turns #{value.inspect} into #{percent}" do
+            params.instance_variable_set(:@query_pairs, [[:a, value]])
+            expect(params.to_s).to eq("a=#{percent}")
+          end
+        end
+
+        {
+          '.' => '%2E', '-' => '%2D', '_' => '%5F', '~' => '%7E',
+        }.each do |value, percent|
+          it "leaves #{value.inspect} instead of turning into #{percent}" do
+            params.instance_variable_set(:@query_pairs, [[:a, value]])
+            expect(params.to_s).to eq("a=#{value}")
+          end
+        end
+      end
+
+      context "when no escape" do
+        before { params.instance_variable_set(:@query_pairs, [[:a, 1], [:b, 2]]) }
+
+        it "returns concatenated query string" do
+          expect(params.to_s).to eq("a=1&b=2")
+        end
+      end
+    end
+
+    context "when query_pairs contains a string" do
+      before { params.instance_variable_set(:@query_pairs, ["{a: 1}"]) }
+
+      it "returns correct string" do
+        expect(params.to_s).to eq("{a: 1}")
+      end
+    end
+  end
+
+  describe "#build_query_pairs" do
+    let(:pairs) { params.method(:build_query_pairs).call(hash) }
+
+    context "when params is empty" do
+      it "returns empty array" do
+        expect(pairs).to eq([])
+      end
+    end
+
+    context "when params is string" do
+      let(:hash) { "{a: 1}" }
+
+      it "wraps it in an array" do
+        expect(pairs).to eq([hash])
+      end
+    end
+
+    context "when params is simple hash" do
+      let(:hash) { {:a => 1, :b => 2} }
+
+      it "transforms" do
+        expect(pairs).to include([:a, 1])
+        expect(pairs).to include([:b, 2])
+      end
+    end
+
+    context "when params is a nested hash" do
+      let(:hash) { {:a => 1, :b => {:c => 2}} }
+
+      it "transforms" do
+        expect(pairs).to include([:a, 1])
+        expect(pairs).to include(["b[c]", 2])
+      end
+    end
+
+    context "when params contains an array" do
+      let(:hash) { {:a => 1, :b => [2, 3]} }
+
+      context "by default" do
+        it "transforms" do
+          expect(pairs).to include([:a, 1])
+          expect(pairs).to include(["b[0]", 2])
+          expect(pairs).to include(["b[1]", 3])
+        end
+      end
+
+      context "when params_encoding is :rack" do
+        before { params.params_encoding = :rack }
+        it "transforms without indexes" do
+          expect(pairs).to include([:a, 1])
+          expect(pairs).to include(["b[]", 2])
+          expect(pairs).to include(["b[]", 3])
+        end
+      end
+
+      context "when params_encoding is :none" do
+        before { params.params_encoding = :none }
+        it "does no transformation" do
+          expect(pairs).to include([:a, 1])
+          expect(pairs).to include([:b, [2, 3]])
+        end
+      end
+    end
+
+    context "when params contains something nested in an array" do
+      context "when string" do
+        let(:hash) { {:a => {:b => ["hello", "world"]}} }
+
+        it "transforms" do
+          expect(pairs).to eq([["a[b][0]", "hello"], ["a[b][1]", "world"]])
+        end
+      end
+
+      context "when hash" do
+        let(:hash) { {:a => {:b => [{:c =>1}, {:d => 2}]}} }
+
+        it "transforms" do
+          expect(pairs).to eq([["a[b][0][c]", 1], ["a[b][1][d]", 2]])
+        end
+      end
+
+      context "when file" do
+        let(:file) { File.open("spec/spec_helper.rb") }
+        let(:file_info) { params.method(:file_info).call(file) }
+        let(:hash) { {:a => {:b => [file]}} }
+        let(:mime_type) { file_info[1] }
+
+        it "transforms" do
+          expect(pairs).to eq([["a[b][0]", file_info]])
+        end
+
+        context "when MIME" do
+          if defined?(MIME)
+            context "when mime type" do
+              it "sets mime type to text" do
+                expect(mime_type).to eq("application/x-ruby")
+              end
+            end
+          end
+
+          context "when no mime type" do
+            let(:file) { Tempfile.new("fubar") }
+
+            it "sets mime type to default application/octet-stream" do
+              expect(mime_type).to eq("application/octet-stream")
+            end
+          end
+        end
+
+        context "when no MIME" do
+          before { hide_const("MIME") }
+
+          it "sets mime type to default application/octet-stream" do
+            expect(mime_type).to eq("application/octet-stream")
+          end
+        end
+      end
+    end
+
+
+    context "when params contains file" do
+      let(:file) { Tempfile.new("fubar") }
+      let(:file_info) { params.method(:file_info).call(file) }
+      let(:hash) { {:a => 1, :b => file} }
+
+      it "transforms" do
+        expect(pairs).to include([:a, 1])
+        expect(pairs).to include([:b, file_info])
+      end
+    end
+
+    context "when params key contains a null byte" do
+      let(:hash) { {:a => "1\0" } }
+
+      it "preserves" do
+        expect(pairs).to eq([[:a, "1\0"]])
+      end
+    end
+
+    context "when params value contains a null byte" do
+      let(:hash) { {"a\0" => 1 } }
+
+      it "preserves" do
+        expect(pairs).to eq([["a\0", 1]])
+      end
+    end
+  end
+
+  describe "#empty?" do
+    context "when params empty" do
+      it "returns true" do
+        expect(params.empty?).to be_truthy
+      end
+    end
+
+    context "when params not empty" do
+      let(:hash) { {:a => 1} }
+
+      it "returns false" do
+        expect(params.empty?).to be_falsey
+      end
+    end
+  end
+end

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/ethon-0.16.0/spec/ethon/easy/response_callbacks_spec.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Ethon::Easy::ResponseCallbacks do
+  let(:easy) { Ethon::Easy.new }
+
+  [:on_complete, :on_headers, :on_body, :on_progress].each do |callback_type|
+    describe "##{callback_type}" do
+      it "responds" do
+        expect(easy).to respond_to("#{callback_type}")
+      end
+
+      context "when no block given" do
+        it "returns @#{callback_type}" do
+          expect(easy.send("#{callback_type}")).to eq([])
+        end
+      end
+
+      context "when block given" do
+        it "stores" do
+          easy.send(callback_type) { p 1 }
+          expect(easy.instance_variable_get("@#{callback_type}").size).to eq(1)
+        end
+      end
+
+      context "when multiple blocks given" do
+        it "stores" do
+          easy.send(callback_type) { p 1 }
+          easy.send(callback_type) { p 2 }
+          expect(easy.instance_variable_get("@#{callback_type}").size).to eq(2)
+        end
+      end
+    end
+  end
+
+  describe "#complete" do
+    before do
+      easy.on_complete {|r| String.new(r.url) }
+    end
+
+    it "executes blocks and passes self" do
+      expect(String).to receive(:new).with(easy.url)
+      easy.complete
+    end
+
+    context "when @on_complete nil" do
+      it "doesn't raise" do
+        easy.instance_variable_set(:@on_complete, nil)
+        expect{ easy.complete }.to_not raise_error
+      end
+    end
+  end
+
+  describe "#headers" do
+    before do
+      easy.on_headers {|r| String.new(r.url) }
+    end
+
+    it "executes blocks and passes self" do
+      expect(String).to receive(:new).with(easy.url)
+      easy.headers
+    end
+
+    context "when @on_headers nil" do
+      it "doesn't raise" do
+        easy.instance_variable_set(:@on_headers, nil)
+        expect{ easy.headers }.to_not raise_error
+      end
+    end
+  end
+
+  describe "#progress" do
+    context "when requesting for realz" do
+      it "executes callback" do
+        post = Ethon::Easy::Http::Post.new("http://localhost:3001", {:body => "bar=fu"})
+        post.setup(easy)
+        @called = false
+        @has_dltotal = false
+        @has_ultotal = false
+        easy.on_progress { @called = true }
+        easy.on_progress { |dltotal, _, _, _| @has_dltotal ||= true }
+        easy.on_progress { |_, _, ultotal, _| @has_ultotal ||= true }
+        easy.perform
+        expect(@called).to be true
+        expect(@has_dltotal).to be true
+        expect(@has_ultotal).to be true
+      end
+    end
+
+    context "when pretending" do
+      before do
+        @dltotal = nil
+        @dlnow = nil
+        @ultotal = nil
+        @ulnow = nil
+        easy.on_progress { |dltotal, dlnow, ultotal, ulnow| @dltotal = dltotal ; @dlnow = dlnow; @ultotal = ultotal; @ulnow = ulnow }
+      end
+
+      it "executes blocks and passes dltotal" do
+        easy.progress(1, 2, 3, 4)
+        expect(@dltotal).to eq(1)
+      end
+
+      it "executes blocks and passes dlnow" do
+        easy.progress(1, 2, 3, 4)
+        expect(@dlnow).to eq(2)
+      end
+
+      it "executes blocks and passes ultotal" do
+        easy.progress(1, 2, 3, 4)
+        expect(@ultotal).to eq(3)
+      end
+
+      it "executes blocks and passes ulnow" do
+        easy.progress(1, 2, 3, 4)
+        expect(@ulnow).to eq(4)
+      end
+
+      context "when @on_progress nil" do
+        it "doesn't raise" do
+          easy.instance_variable_set(:@on_progress, nil)
+          expect{ easy.progress(1, 2, 3, 4) }.to_not raise_error
+        end
+      end
+    end
+  end
+
+  describe "#body" do
+    before do
+      @chunk = nil
+      @r = nil
+      easy.on_body { |chunk, r| @chunk = chunk ; @r = r }
+    end
+
+    it "executes blocks and passes self" do
+      easy.body("the chunk")
+      expect(@r).to be(easy)
+    end
+
+    it "executes blocks and passes chunk" do
+      easy.body("the chunk")
+      expect(@chunk).to eq("the chunk")
+    end
+
+    context "when @on_body nil" do
+      it "doesn't raise" do
+        easy.instance_variable_set(:@on_body, nil)
+        expect{ easy.body("the chunk") }.to_not raise_error
+      end
+    end
+  end
+end

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/ethon-0.16.0/spec/ethon/easy/util_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Ethon::Easy::Util do
+  class Dummy
+    include Ethon::Easy::Util
+  end
+
+  let(:klass) { Dummy.new }
+
+  describe "escape_zero_byte" do
+    context "when value has no zero byte" do
+      let(:value) { "hello world" }
+
+      it "returns same value" do
+        expect(klass.escape_zero_byte(value)).to be(value)
+      end
+    end
+
+    context "when value has zero byte" do
+      let(:value) { "hello \0world" }
+
+      it "returns escaped" do
+        expect(klass.escape_zero_byte(value)).to eq("hello \\0world")
+      end
+    end
+  end
+end

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/ethon-0.16.0/spec/ethon/easy_spec.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Ethon::Easy do
+  let(:easy) { Ethon::Easy.new }
+
+  describe ".new" do
+    it "inits curl" do
+      expect(Ethon::Curl).to receive(:init)
+      easy
+    end
+
+    context "when options are empty" do
+      it "sets only callbacks" do
+        expect_any_instance_of(Ethon::Easy).to receive(:set_callbacks)
+        expect(Ethon::Easy).to receive(:set_option).never
+        easy
+      end
+    end
+
+    context "when options not empty" do
+      context "when followlocation is set" do
+        let(:options) { { :followlocation => true } }
+        let(:easy) { Ethon::Easy.new(options) }
+
+        it "sets followlocation" do
+          expect_any_instance_of(Ethon::Easy).to receive(:set_callbacks)
+          expect(Ethon::Curl).to receive(:set_option).with(:followlocation, true, anything)
+          easy
+        end
+      end
+    end
+  end
+
+  describe "#set_attributes" do
+    context "when options are empty" do
+      it "sets only callbacks" do
+        expect_any_instance_of(Ethon::Easy).to receive(:set_callbacks)
+        expect(Ethon::Easy).to receive(:set_option).never
+        easy
+      end
+    end
+
+    context "when options aren't empty" do
+      context "when valid key" do
+        it "sets" do
+          expect(easy).to receive(:verbose=).with(true)
+          easy.set_attributes({:verbose => true})
+        end
+      end
+
+      context "when invalid key" do
+        it "raises invalid option error" do
+          expect{ easy.set_attributes({:fubar => 1}) }.to raise_error(Ethon::Errors::InvalidOption)
+        end
+      end
+    end
+  end
+
+  describe "#reset" do
+    before { easy.url = "www.example.com" }
+
+    it "resets url" do
+      easy.reset
+      expect(easy.url).to be_nil
+    end
+
+    it "resets escape?" do
+      easy.escape = false
+      easy.reset
+      expect(easy.escape?).to be_truthy
+    end
+
+    it "resets hash" do
+      easy.reset
+      expect(easy.instance_variable_get(:@hash)).to be_nil
+    end
+
+    it "resets easy handle" do
+      expect(Ethon::Curl).to receive(:easy_reset)
+      easy.reset
+    end
+
+    it "resets on_complete" do
+      easy.on_complete { p 1 }
+      easy.reset
+      expect(easy.on_complete).to be_empty
+    end
+
+    it "resets on_headers" do
+      easy.on_headers { p 1 }
+      easy.reset
+      expect(easy.on_headers).to be_empty
+    end
+
+    it "resets on_body" do
+      easy.on_body { p 1 }
+      easy.reset
+      expect(easy.on_body).to be_empty
+    end
+  end
+
+  describe "#dup" do
+    let!(:easy) do
+      easy = Ethon::Easy.new
+      easy.url = "http://localhost:3001/"
+      easy.on_complete { 'on_complete' }
+      easy.on_headers { 'on_headers' }
+      easy.on_progress { 'on_progress' }
+      easy.response_body = String.new('test_body')
+      easy.response_headers = String.new('test_headers')
+      easy
+    end
+    let!(:e) { easy.dup }
+
+    it "sets a new handle" do
+      expect(e.handle).not_to eq(easy.handle)
+    end
+
+    it "preserves url" do
+      expect(e.url).to eq(easy.url)
+    end
+
+    it "preserves on_complete callback" do
+      expect(e.on_complete).to be(easy.on_complete)
+    end
+
+    it "preserves on_headers callback" do
+      expect(e.on_headers).to be(easy.on_headers)
+    end
+
+    it 'preserves body_write_callback of original handle' do
+      expect { easy.perform }.to change { easy.response_body }
+      expect { easy.perform }.not_to change { e.response_body }
+    end
+
+    it "preserves on_progress callback" do
+      expect(e.on_progress).to be(easy.on_progress)
+    end
+
+    it 'sets new body_write_callback of duplicated handle' do
+      expect { e.perform }.to change { e.response_body }
+      expect { e.perform }.not_to change { easy.response_body }
+    end
+
+    it 'preserves headers_write_callback of original handle' do
+      expect { easy.perform }.to change { easy.response_headers }
+      expect { easy.perform }.not_to change { e.response_headers }
+    end
+
+    it 'sets new headers_write_callback of duplicated handle' do
+      expect { e.perform }.to change { e.response_headers }
+      expect { e.perform }.not_to change { easy.response_headers }
+    end
+
+    it "resets response_body" do
+      expect(e.response_body).to be_empty
+    end
+
+    it "resets response_headers" do
+      expect(e.response_headers).to be_empty
+    end
+
+    it "sets response_body for duplicated Easy" do
+      e.perform
+      expect(e.response_body).not_to be_empty
+    end
+
+    it "sets response_headers for duplicated Easy" do
+      e.perform
+      expect(e.response_headers).not_to be_empty
+    end
+
+    it "preserves response_body for original Easy" do
+      e.perform
+      expect(easy.response_body).to eq('test_body')
+    end
+
+    it "preserves response_headers for original Easy" do
+      e.perform
+      expect(easy.response_headers).to eq('test_headers')
+    end
+  end
+
+  describe "#mirror" do
+    it "returns a Mirror" do
+      expect(easy.mirror).to be_a(Ethon::Easy::Mirror)
+    end
+
+    it "builds from easy" do
+      expect(Ethon::Easy::Mirror).to receive(:from_easy).with(easy)
+      easy.mirror
+    end
+  end
+
+  describe "#log_inspect" do
+    [ :url, :response_code, :return_code, :total_time ].each do |name|
+      it "contains #{name}" do
+        expect(easy.log_inspect).to match name.to_s
+      end
+    end
+  end
+end

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/ethon-0.16.0/spec/ethon/libc_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Ethon::Libc do
+  describe "#getdtablesize", :if => !Ethon::Curl.windows? do
+    it "returns an integer" do
+      expect(Ethon::Libc.getdtablesize).to be_a(Integer)
+    end
+
+    it "returns bigger zero", :if => !Ethon::Curl.windows? do
+      expect(Ethon::Libc.getdtablesize).to_not be_zero
+    end
+  end
+end

data/.github/.example/vendor/bundle/ruby/3.3.0/gems/ethon-0.16.0/spec/ethon/loggable_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe Ethon::Loggable do
+
+  describe "#logger=" do
+
+    let(:logger) do
+      Logger.new($stdout).tap do |log|
+        log.level = Logger::INFO
+      end
+    end
+
+    before do
+      Ethon.logger = logger
+    end
+
+    it "sets the logger" do
+      expect(Ethon.logger).to eq(logger)
+    end
+  end
+end