cloudsmith-api 2.0.21 → 2.0.22

data/vendor/bundle/ruby/2.6.0/gems/typhoeus-1.4.1/spec/support/localhost_server.rb

@@ -1,94 +0,0 @@
-require 'rack'
-require 'rack/handler/webrick'
-require 'net/http'
-
-# The code for this is inspired by Capybara's server:
-#   http://github.com/jnicklas/capybara/blob/0.3.9/lib/capybara/server.rb
-class LocalhostServer
-  READY_MESSAGE = "Server ready"
-
-  class Identify
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      if env["PATH_INFO"] == "/__identify__"
-        [200, {}, [LocalhostServer::READY_MESSAGE]]
-      else
-        @app.call(env)
-      end
-    end
-  end
-
-  attr_reader :port
-
-  def initialize(rack_app, port = nil)
-    @port = port || find_available_port
-    @rack_app = rack_app
-    concurrently { boot }
-    wait_until(10, "Boot failed.") { booted? }
-  end
-
-  private
-
-  def find_available_port
-    server = TCPServer.new('127.0.0.1', 0)
-    server.addr[1]
-  ensure
-    server.close if server
-  end
-
-  def boot
-    # Use WEBrick since it's part of the ruby standard library and is available on all ruby interpreters.
-    options = { :Port => port }
-    options.merge!(:AccessLog => [], :Logger => WEBrick::BasicLog.new(StringIO.new)) unless ENV['VERBOSE_SERVER']
-    Rack::Handler::WEBrick.run(Identify.new(@rack_app), options)
-  end
-
-  def booted?
-    res = ::Net::HTTP.get_response("localhost", '/__identify__', port)
-    if res.is_a?(::Net::HTTPSuccess) or res.is_a?(::Net::HTTPRedirection)
-      return res.body == READY_MESSAGE
-    end
-  rescue Errno::ECONNREFUSED, Errno::EBADF
-    return false
-  end
-
-  def concurrently
-    if should_use_subprocess?
-      pid = Process.fork do
-        trap(:INT) { ::Rack::Handler::WEBrick.shutdown }
-        yield
-        exit # manually exit; otherwise this sub-process will re-run the specs that haven't run yet.
-      end
-
-      at_exit do
-        Process.kill('INT', pid)
-        begin
-          Process.wait(pid)
-        rescue Errno::ECHILD
-          # ignore this error...I think it means the child process has already exited.
-        end
-      end
-    else
-      Thread.new { yield }
-    end
-  end
-
-  def should_use_subprocess?
-    # !ENV['THREADED']
-    false
-  end
-
-  def wait_until(timeout, error_message, &block)
-    start_time = Time.now
-
-    while true
-      return if yield
-      raise TimeoutError.new(error_message) if (Time.now - start_time) > timeout
-      sleep(0.05)
-    end
-  end
-end
-

data/vendor/bundle/ruby/2.6.0/gems/typhoeus-1.4.1/spec/support/memory_cache.rb

@@ -1,15 +0,0 @@
-class MemoryCache
-  attr_reader :memory
-
-  def initialize
-    @memory = {}
-  end
-
-  def get(request)
-    memory[request]
-  end
-
-  def set(request, response)
-    memory[request] = response
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/typhoeus-1.4.1/spec/support/server.rb

@@ -1,116 +0,0 @@
-#!/usr/bin/env ruby
-require 'json'
-require 'zlib'
-require 'sinatra/base'
-require 'rack/typhoeus'
-
-TESTSERVER = Sinatra.new do
-  set :logging, false
-  use Rack::Typhoeus::Middleware::ParamsDecoder
-
-  fail_count = 0
-
-  post '/file' do
-    {
-      'content-type' => params[:file][:type],
-      'filename' => params[:file][:filename],
-      'content' => params[:file][:tempfile].read,
-      'request-content-type' => request.env['CONTENT_TYPE']
-    }.to_json
-  end
-
-  get '/multiple-headers' do
-    [200, { 'Set-Cookie' => %w[ foo bar ], 'Content-Type' => 'text/plain' }, ['']]
-  end
-
-  get '/cookies-test' do
-    [200, { 'Set-Cookie' => %w(foo=bar bar=foo), 'Content-Type' => 'text/plain' }, ['']]
-  end
-
-  get '/cookies-test2' do
-    [200, { 'Set-Cookie' => %w(foo2=bar bar2=foo), 'Content-Type' => 'text/plain' }, ['']]
-  end
-
-  get '/fail/:number' do
-    if fail_count >= params[:number].to_i
-      "ok"
-    else
-      fail_count += 1
-      error 500, "oh noes!"
-    end
-  end
-
-  get '/fail_forever' do
-    error 500, "oh noes!"
-  end
-
-  get '/redirect' do
-    redirect '/'
-  end
-
-  get '/bad_redirect' do
-    redirect '/bad_redirect'
-  end
-
-  get '/auth_basic/:username/:password' do
-    @auth ||=  Rack::Auth::Basic::Request.new(request.env)
-    # Check that we've got a basic auth, and that it's credentials match the ones
-    # provided in the request
-    if @auth.provided? && @auth.basic? && @auth.credentials == [ params[:username], params[:password] ]
-      # auth is valid - confirm it
-      true
-    else
-      # invalid auth - request the authentication
-      response['WWW-Authenticate'] = %(Basic realm="Testing HTTP Auth")
-      throw(:halt, [401, "Not authorized\n"])
-    end
-  end
-
-  get '/auth_ntlm' do
-    # we're just checking for the existence if NTLM auth header here. It's validation
-    # is too troublesome and really doesn't bother is much, it's up to libcurl to make
-    # it valid
-    response['WWW-Authenticate'] = 'NTLM'
-    is_ntlm_auth = /^NTLM/ =~ request.env['HTTP_AUTHORIZATION']
-    true if is_ntlm_auth
-    throw(:halt, [401, "Not authorized\n"]) if !is_ntlm_auth
-  end
-
-  get '/gzipped' do
-    req_env = request.env.to_json
-    z = Zlib::Deflate.new
-    gzipped_env = z.deflate(req_env, Zlib::FINISH)
-    z.close
-    response['Content-Encoding'] = 'gzip'
-    gzipped_env
-  end
-
-  get '/**' do
-    sleep params["delay"].to_i if params.has_key?("delay")
-    request.env.merge!(:body => request.body.read).to_json
-  end
-
-  head '/**' do
-    sleep params["delay"].to_i if params.has_key?("delay")
-  end
-
-  put '/**' do
-    request.env.merge!(:body => request.body.read).to_json
-  end
-
-  post '/**' do
-    request.env.merge!(:body => request.body.read).to_json
-  end
-
-  delete '/**' do
-    request.env.merge!(:body => request.body.read).to_json
-  end
-
-  patch '/**' do
-    request.env.merge!(:body => request.body.read).to_json
-  end
-
-  options '/**' do
-    request.env.merge!(:body => request.body.read).to_json
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/typhoeus-1.4.1/spec/typhoeus/adapters/faraday_spec.rb

@@ -1,339 +0,0 @@
-if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("1.9.0")
-  require 'spec_helper'
-  require 'typhoeus/adapters/faraday'
-
-  describe Faraday::Adapter::Typhoeus do
-    let(:base_url) { "http://localhost:3001" }
-    let(:adapter) { described_class.new(nil) }
-    let(:request) { Typhoeus::Request.new(base_url) }
-    let(:conn) do
-      Faraday.new(:url => base_url) do |faraday|
-        faraday.adapter  :typhoeus
-      end
-    end
-    let(:response) { conn.get("/") }
-
-    context "when parallel" do
-      it "returns a faraday response" do
-        response = nil
-        conn.in_parallel { response = conn.get("/") }
-        expect(response).to be_a(Faraday::Response)
-      end
-
-      it "succeeds" do
-        response = nil
-        conn.in_parallel { response = conn.get("/") }
-        expect(response.status).to be(200)
-      end
-    end
-
-    context "when not parallel" do
-      it "returns a faraday response" do
-        expect(response).to be_a(Faraday::Response)
-      end
-
-      it "succeeds" do
-        expect(response.status).to be(200)
-      end
-    end
-
-    context "when a response is stubbed" do
-      before do
-        stub = Typhoeus::Response.new \
-          :code    => 200,
-          :headers => { "Foo" => "2", "Bar" => "3" },
-          :body    => "Hello",
-          :mock    => true
-
-        Typhoeus.stub(base_url + '/').and_return(stub)
-      end
-
-      it 'stubs the status code' do
-        expect(response.status).to eq(200)
-      end
-
-      it 'stubs the response body' do
-        expect(response.body).to eq("Hello")
-      end
-
-      it 'stubs the headers' do
-        expect(response.headers).to eq("Foo" => "2", "Bar" => "3")
-      end
-    end
-
-    describe "#initialize" do
-      let(:request) { adapter.method(:typhoeus_request).call({}) }
-
-      context "when typhoeus request options specified" do
-        let(:adapter) { described_class.new(nil, { :forbid_reuse => true, :maxredirs => 1 }) }
-
-        it "should set option for request" do
-          expect(request.options[:forbid_reuse]).to be_truthy
-          expect(request.options[:maxredirs]).to eq(1)
-        end
-      end
-    end
-
-    describe "#perform_request" do
-      let(:env) { {} }
-
-      context "when body" do
-        let(:env) { { :body => double(:read => "body") } }
-
-        it "reads body" do
-          expect(adapter.method(:read_body).call(env)).to eq("body")
-        end
-      end
-
-      context "parallel_manager" do
-        context "when given" do
-          let(:env) { { :parallel_manager => double(:queue => true), :ssl => {}, :request => {} } }
-
-          it "uses" do
-            adapter.method(:perform_request).call(env)
-          end
-        end
-
-        context "when not given" do
-          let(:env) { { :method => :get, :ssl => {}, :request => {} } }
-
-          it "falls back to single" do
-            expect(Typhoeus::Request).to receive(:new).and_return(double(:options => {}, :on_complete => [], :run => true))
-            adapter.method(:perform_request).call(env)
-          end
-        end
-      end
-    end
-
-    describe "#request" do
-      let(:env) do
-        { :url => "url", :method => :get, :body => "body", :request_headers => {}, :ssl => {}, :request => {} }
-      end
-
-      let(:request) { adapter.method(:request).call(env) }
-
-      it "returns request" do
-        expect(request).to be_a(Typhoeus::Request)
-      end
-
-      it "sets url" do
-        expect(request.base_url).to eq("url")
-      end
-
-      it "sets http method" do
-        expect(request.original_options[:method]).to eq(:get)
-      end
-
-      it "sets body" do
-        expect(request.original_options[:body]).to eq("body")
-      end
-
-      it "sets headers" do
-        expect(request.original_options[:headers]).to eq({})
-      end
-
-      it "sets on_complete callback" do
-        expect(request.on_complete.size).to eq(1)
-      end
-    end
-
-    context "when the connection failed" do
-      before do
-        stub = Typhoeus::Response.new \
-          :response_code => 0,
-          :return_code => 0,
-          :mock          => true
-
-        Typhoeus.stub(base_url + '/').and_return(stub)
-      end
-
-      context "when parallel" do
-        it "isn't successful" do
-          response = nil
-          conn.in_parallel { response = conn.get("/") }
-          expect(response.success?).to be_falsey
-        end
-
-        it "translates the response code into an error message" do
-          response = nil
-          conn.in_parallel { response = conn.get("/") }
-          expect(response.env[:typhoeus_return_message]).to eq("No error")
-        end
-      end
-
-      context "when not parallel" do
-        it "raises an error" do
-          expect { conn.get("/") }.to raise_error(Faraday::ConnectionFailed, "No error")
-        end
-      end
-    end
-
-    describe "#configure_socket" do
-      let(:env) { { :request => { :bind => { :host => "interface" } } } }
-
-      before { adapter.method(:configure_socket).call(request, env) }
-
-      context "when host" do
-        it "sets interface" do
-          expect(request.options[:interface]).to eq("interface")
-        end
-      end
-    end
-
-    describe "#configure_timeout" do
-      before { adapter.method(:configure_timeout).call(request, env) }
-
-      context "when timeout" do
-        let(:env) { { :request => { :timeout => 1 } } }
-
-        it "sets timeout_ms" do
-          expect(request.options[:timeout_ms]).to eq(1000)
-        end
-      end
-
-      context "when open_timeout" do
-        let(:env) { { :request => { :open_timeout => 1 } } }
-
-        it "sets connecttimeout_ms" do
-          expect(request.options[:connecttimeout_ms]).to eq(1000)
-        end
-      end
-    end
-
-    describe "#configure_proxy" do
-      before { adapter.method(:configure_proxy).call(request, env) }
-
-      context "when proxy" do
-        let(:env) { { :request => { :proxy => { :uri => double(:scheme => 'http', :host => "localhost", :port => "3001") } } } }
-
-        it "sets proxy" do
-          expect(request.options[:proxy]).to eq("http://localhost:3001")
-        end
-
-        context "when username and password" do
-          let(:env) do
-            { :request => { :proxy => {
-              :uri => double(:scheme => 'http', :host => :a, :port => :b),
-              :user => "a",
-              :password => "b"
-            } } }
-          end
-
-          it "sets proxyuserpwd" do
-            expect(request.options[:proxyuserpwd]).to eq("a:b")
-          end
-        end
-      end
-    end
-
-    describe "#configure_ssl" do
-      before { adapter.method(:configure_ssl).call(request, env) }
-
-      context "when version" do
-        let(:env) { { :ssl => { :version => "a" } } }
-
-        it "sets sslversion" do
-          expect(request.options[:sslversion]).to eq("a")
-        end
-      end
-
-      context "when client_cert" do
-        let(:env) { { :ssl => { :client_cert => "a" } } }
-
-        it "sets sslcert" do
-          expect(request.options[:sslcert]).to eq("a")
-        end
-      end
-
-      context "when client_key"  do
-        let(:env) { { :ssl => { :client_key => "a" } } }
-
-        it "sets sslkey" do
-          expect(request.options[:sslkey]).to eq("a")
-        end
-      end
-
-      context "when ca_file"  do
-        let(:env) { { :ssl => { :ca_file => "a" } } }
-
-        it "sets cainfo" do
-          expect(request.options[:cainfo]).to eq("a")
-        end
-      end
-
-      context "when ca_path" do
-        let(:env) { { :ssl => { :ca_path => "a" } } }
-
-        it "sets capath" do
-          expect(request.options[:capath]).to eq("a")
-        end
-      end
-
-      context "when client_cert_passwd" do
-        let(:env) { { :ssl => { :client_cert_passwd => "a" } } }
-
-        it "sets keypasswd to the value of client_cert_passwd" do
-          expect(request.options[:keypasswd]).to eq("a")
-        end
-      end
-
-      context "when client_certificate_password" do
-        let(:env) { { :ssl => { :client_certificate_password => "a" } } }
-
-        it "sets keypasswd to the value of client_cert_passwd" do
-          expect(request.options[:keypasswd]).to eq("a")
-        end
-      end
-
-      context "when no client_cert_passwd" do
-        let(:env) { { :ssl => { } } }
-
-        it "does not set keypasswd on options" do
-          expect(request.options).not_to have_key :keypasswd
-        end
-      end
-
-      context "when verify is false" do
-        let(:env) { { :ssl => { :verify => false } } }
-
-        it "sets ssl_verifyhost to 0" do
-          expect(request.options[:ssl_verifyhost]).to eq(0)
-        end
-
-        it "sets ssl_verifypeer to false" do
-          expect(request.options[:ssl_verifypeer]).to be_falsey
-        end
-      end
-
-      context "when verify is true" do
-        let(:env) { { :ssl => { :verify => true } } }
-
-        it "sets ssl_verifyhost to 2" do
-          expect(request.options[:ssl_verifyhost]).to eq(2)
-        end
-
-        it "sets ssl_verifypeer to true" do
-          expect(request.options[:ssl_verifypeer]).to be_truthy
-        end
-      end
-    end
-
-    describe "#parallel?" do
-      context "when parallel_manager" do
-        let(:env) { { :parallel_manager => true } }
-
-        it "returns true" do
-          expect(adapter.method(:parallel?).call(env)).to be_truthy
-        end
-      end
-
-      context "when no parallel_manager" do
-        let(:env) { { :parallel_manager => nil } }
-
-        it "returns false" do
-          expect(adapter.method(:parallel?).call(env)).to be_falsey
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/typhoeus-1.4.1/spec/typhoeus/cache/dalli_spec.rb

@@ -1,41 +0,0 @@
-if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("1.9.0")
-  require 'dalli'
-  require 'typhoeus/cache/dalli'
-  require 'spec_helper'
-
-  describe Typhoeus::Cache::Dalli do
-    let(:dalli) { instance_double(Dalli::Client) }
-    let(:cache) { Typhoeus::Cache::Dalli.new(dalli) }
-
-    let(:base_url) { "localhost:3001" }
-    let(:request) { Typhoeus::Request.new(base_url, {:method => :get}) }
-    let(:response) { Typhoeus::Response.new(:response_code => 0, :return_code => 0, :mock => true) }
-
-    describe "#set" do
-      it "sends the request to Dalli" do
-        expect(dalli).to receive(:set).with(request.cache_key, response, nil)
-
-        cache.set(request, response)
-      end
-    end
-
-    describe "#get" do
-      it "returns nil when the key is not in the cache" do
-        expect(dalli).to receive(:get).with(request.cache_key).and_return(nil)
-
-        expect(cache.get(request)).to be_nil
-      end
-
-      it "returns the cached response when the key is in cache" do
-        expect(dalli).to receive(:get).with(request.cache_key).and_return(response)
-
-        result = cache.get(request)
-        expect(result).to_not be_nil
-        expect(result.response_code).to eq(response.response_code)
-        expect(result.return_code).to eq(response.return_code)
-        expect(result.headers).to eq(response.headers)
-        expect(result.body).to eq(response.body)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/typhoeus-1.4.1/spec/typhoeus/cache/redis_spec.rb

@@ -1,41 +0,0 @@
-require 'redis'
-require 'typhoeus/cache/redis'
-require 'spec_helper'
-
-describe Typhoeus::Cache::Redis do
-  let(:redis) { instance_double(Redis) }
-  let(:cache) { Typhoeus::Cache::Redis.new(redis) }
-
-  let(:base_url) { "localhost:3001" }
-  let(:request) { Typhoeus::Request.new(base_url, {:method => :get}) }
-  let(:response) { Typhoeus::Response.new(:response_code => 0, :return_code => 0, :mock => true) }
-  let(:serialized_response) { Marshal.dump(response) }
-
-  describe "#set" do
-    it "sends the serialized request to Redis" do
-      expect(redis).to receive(:set).with(request.cache_key, serialized_response)
-      expect(redis).to_not receive(:expire).with(request.cache_key, request.cache_ttl)
-
-      cache.set(request, response)
-    end
-  end
-
-  describe "#get" do
-    it "returns nil when the key is not in Redis" do
-      expect(redis).to receive(:get).with(request.cache_key).and_return(nil)
-
-      expect(cache.get(request)).to be_nil
-    end
-
-    it "returns the cached response when the key is in Redis" do
-      expect(redis).to receive(:get).with(request.cache_key).and_return(serialized_response)
-
-      result = cache.get(request)
-      expect(result).to_not be_nil
-      expect(result.response_code).to eq(response.response_code)
-      expect(result.return_code).to eq(response.return_code)
-      expect(result.headers).to eq(response.headers)
-      expect(result.body).to eq(response.body)
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/typhoeus-1.4.1/spec/typhoeus/config_spec.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-
-describe Typhoeus::Config do
-  let(:config) { Typhoeus::Config }
-
-  [:block_connection, :memoize, :verbose, :cache, :user_agent, :proxy].each do |name|
-    it "responds to #{name}" do
-      expect(config).to respond_to(name)
-    end
-
-    it "responds to #{name}=" do
-      expect(config).to respond_to("#{name}=")
-    end
-  end
-end