webmock 3.14.0 → 3.25.0

data/minitest/webmock_spec.rb

@@ -1,60 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/test_helper')
-
-  describe "Webmock" do
-    include HttpRequestTestHelper
-
-    before do
-      @stub_http = stub_http_request(:any, "http://www.example.com")
-      @stub_https = stub_http_request(:any, "https://www.example.com")
-    end
-
-    it "should update assertions count" do
-      assert_equal 0, assertions
-      http_request(:get, "http://www.example.com/")
-
-      assert_requested(@stub_http)
-      assert_equal 2, assertions
-
-      assert_not_requested(:post, "http://www.example.com")
-      assert_equal 4, assertions
-    end
-
-    it "should raise error on non stubbed request" do
-      lambda { http_request(:get, "http://www.example.net/") }.must_raise(WebMock::NetConnectNotAllowedError)
-    end
-
-    it "should verify that expected request occured" do
-      http_request(:get, "http://www.example.com/")
-      assert_requested(:get, "http://www.example.com", times: 1)
-      assert_requested(:get, "http://www.example.com")
-    end
-
-    it "should verify that expected http stub occured" do
-      http_request(:get, "http://www.example.com/")
-      assert_requested(@stub_http, times: 1)
-      assert_requested(@stub_http)
-    end
-
-    it "should verify that expected https stub occured" do
-      http_request(:get, "https://www.example.com/")
-      http_request(:get, "https://www.example.com/")
-      assert_requested(@stub_https, times: 2)
-    end
-
-    it  "should verify that expect request didn't occur" do
-     expected_message = "The request GET http://www.example.com/ was expected to execute 1 time but it executed 0 times"
-     expected_message += "\n\nThe following requests were made:\n\nNo requests were made.\n============================================================"
-     assert_fail(expected_message) do
-       assert_requested(:get, "http://www.example.com")
-     end
-    end
-
-    it  "should verify that expect stub didn't occur" do
-     expected_message = "The request ANY http://www.example.com/ was expected to execute 1 time but it executed 0 times"
-     expected_message += "\n\nThe following requests were made:\n\nNo requests were made.\n============================================================"
-     assert_fail(expected_message) do
-       assert_requested(@stub_http)
-     end
-    end
-  end
-

data/spec/acceptance/async_http_client/async_http_client_spec.rb

@@ -1,375 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-require 'acceptance/webmock_shared'
-require_relative './async_http_client_spec_helper'
-
-require 'protocol/http/body/file'
-
-Async.logger.debug! if ENV['ASYNC_LOGGER_DEBUG']
-
-unless RUBY_PLATFORM =~ /java/
-  describe 'Async::HTTP::Client' do
-    include AsyncHttpClientSpecHelper
-
-    include_context "with WebMock",
-      :no_status_message,
-      :no_url_auth,
-      :no_content_length_header
-
-    it 'works' do
-      stub_request(:get, 'http://www.example.com')
-      expect(make_request(:get, 'http://www.example.com')).to eq(
-        status: 200,
-        headers: {},
-        body: nil
-      )
-    end
-
-    it 'works with request path' do
-      stub_request(:get, 'http://www.example.com/foo')
-      expect(make_request(:get, 'http://www.example.com/foo')).to eq(
-        status: 200,
-        headers: {},
-        body: nil
-      )
-    end
-
-    it 'works with request query' do
-      stub_request(:get, 'http://www.example.com/').with(
-        query: {
-          'foo' => 'bar'
-        }
-      )
-      expect(make_request(:get, 'http://www.example.com/?foo=bar')).to eq(
-        status: 200,
-        headers: {},
-        body: nil
-      )
-    end
-
-    it 'works with request headers' do
-      stub_request(:get, 'http://www.example.com').with(
-        headers: {
-          'X-Token' => 'Token'
-        }
-      )
-      expect(
-        make_request :get, 'http://www.example.com',
-          headers: {
-            'X-Token' => 'Token'
-        }
-      ).to eq(
-        status: 200,
-        headers: {},
-        body: nil
-      )
-    end
-
-    it 'works with request body as text' do
-      stub_request(:post, 'http://www.example.com').with(
-        body: 'x'*10_000
-      )
-      expect(
-        make_request :post, 'http://www.example.com',
-          body: 'x'*10_000
-      ).to eq(
-        status: 200,
-        headers: {},
-        body: nil
-      )
-    end
-
-    it 'works with request body as file' do
-      stub_request(:post, "www.example.com").with(
-        body: File.read(__FILE__)
-      )
-      expect(
-        make_request :post, "http://www.example.com",
-          body: ::Protocol::HTTP::Body::File.open(__FILE__, block_size: 32)
-      ).to eq(
-        status: 200,
-        headers: {},
-        body: nil
-      )
-    end
-
-    it 'works with response status' do
-      stub_request(:get, 'http://www.example.com').to_return(
-        status: 400
-      )
-      expect(make_request(:get, 'http://www.example.com')).to eq(
-        status: 400,
-        headers: {},
-        body: nil
-      )
-    end
-
-    it 'works with response headers' do
-      stub_request(:get, 'http://www.example.com').to_return(
-        headers: {
-          'X-Token' => 'TOKEN'
-        }
-      )
-      expect(make_request(:get, 'http://www.example.com')).to eq(
-        status: 200,
-        headers: {
-          'x-token' => ['TOKEN']
-        },
-        body: nil
-      )
-    end
-
-    it 'works with response body' do
-      stub_request(:get, 'http://www.example.com').to_return(
-        body: 'abc'
-      )
-      expect(make_request(:get, 'http://www.example.com')).to eq(
-        status: 200,
-        headers: {},
-        body: 'abc'
-      )
-    end
-
-    it 'works with to_timeout' do
-      stub_request(:get, 'http://www.example.com').to_timeout
-      expect { make_request(:get, 'http://www.example.com') }.to raise_error Async::TimeoutError
-    end
-
-    it 'does not invoke "after real request" callbacks for stubbed requests' do
-      WebMock.allow_net_connect!
-      stub_request(:get, 'http://www.example.com').to_return(body: 'abc')
-
-      callback_invoked = false
-      WebMock.after_request(real_requests_only: true) { |_| callback_invoked = true }
-
-      make_request(:get, 'http://www.example.com')
-      expect(callback_invoked).to eq(false)
-    end
-
-    it 'does invoke "after request" callbacks for stubbed requests' do
-      WebMock.allow_net_connect!
-      stub_request(:get, 'http://www.example.com').to_return(body: 'abc')
-
-      callback_invoked = false
-      WebMock.after_request(real_requests_only: false) { |_| callback_invoked = true }
-
-      make_request(:get, 'http://www.example.com')
-      expect(callback_invoked).to eq(true)
-    end
-
-    context 'scheme and protocol' do
-      let(:default_response_headers) { {} }
-
-      before do
-        stub_request(
-          :get, "#{scheme}://www.example.com"
-        ).and_return(
-          body: 'BODY'
-        )
-      end
-
-      subject do
-        make_request(:get, "#{scheme}://www.example.com", protocol: protocol)
-      end
-
-      shared_examples :common do
-        specify do
-          expect(subject).to eq(
-            status: 200,
-            headers: default_response_headers,
-            body: 'BODY'
-          )
-        end
-      end
-
-      context 'http scheme' do
-        let(:scheme) { 'http' }
-
-        context 'default protocol' do
-          let(:protocol) { nil }
-
-          include_examples :common
-        end
-
-        context 'HTTP10 protocol' do
-          let(:protocol) { Async::HTTP::Protocol::HTTP10 }
-          let(:default_response_headers) { {"connection"=>["keep-alive"]} }
-
-          include_examples :common
-        end
-
-        context 'HTTP11 protocol' do
-          let(:protocol) { Async::HTTP::Protocol::HTTP11 }
-
-          include_examples :common
-        end
-
-        context 'HTTP2 protocol' do
-          let(:protocol) { Async::HTTP::Protocol::HTTP2 }
-
-          include_examples :common
-        end
-      end
-
-      context 'https scheme' do
-        let(:scheme) { 'https' }
-
-        context 'default protocol' do
-          let(:protocol) { nil }
-
-          include_examples :common
-        end
-
-        context 'HTTP10 protocol' do
-          let(:protocol) { Async::HTTP::Protocol::HTTP10 }
-          let(:default_response_headers) { {"connection"=>["keep-alive"]} }
-
-          include_examples :common
-        end
-
-        context 'HTTP11 protocol' do
-          let(:protocol) { Async::HTTP::Protocol::HTTP11 }
-
-          include_examples :common
-        end
-
-        context 'HTTP2 protocol' do
-          let(:protocol) { Async::HTTP::Protocol::HTTP2 }
-
-          include_examples :common
-        end
-
-        context 'HTTPS protocol' do
-          let(:protocol) { Async::HTTP::Protocol::HTTPS }
-
-          include_examples :common
-        end
-      end
-    end
-
-    context 'multiple requests' do
-      let(:endpoint) { Async::HTTP::Endpoint.parse('http://www.example.com') }
-      let(:requests_count) { 3 }
-
-      shared_examples :common do
-        before do
-          requests_count.times do |index|
-            stub_request(
-              :get, "http://www.example.com/foo#{index}"
-            ).to_return(
-              status: 200 + index,
-              headers: {'X-Token' => "foo#{index}"},
-              body: "FOO#{index}"
-            )
-          end
-        end
-
-       specify do
-         expect(subject).to eq(
-           0 => {
-             status: 200,
-             headers: {'x-token' => ['foo0']},
-             body: 'FOO0'
-           },
-           1 => {
-             status: 201,
-             headers: {'x-token' => ['foo1']},
-             body: 'FOO1'
-           },
-           2 => {
-             status: 202,
-             headers: {'x-token' => ['foo2']},
-             body: 'FOO2'
-           }
-         )
-       end
-      end
-
-      context 'sequential' do
-        subject do
-          responses = {}
-          Async do |task|
-            Async::HTTP::Client.open(endpoint, protocol) do |client|
-              requests_count.times do |index|
-                response = client.get "/foo#{index}"
-                responses[index] = response_to_hash(response)
-              end
-            end
-          end
-          responses
-        end
-
-        context 'HTTP1 protocol' do
-          let(:protocol) { Async::HTTP::Protocol::HTTP1 }
-
-          include_examples :common
-        end
-
-        context 'HTTP2 protocol' do
-          let(:protocol) { Async::HTTP::Protocol::HTTP2 }
-
-          include_examples :common
-        end
-      end
-
-      context 'asynchronous' do
-        subject do
-          responses = {}
-          Async do |task|
-            Async::HTTP::Client.open(endpoint, protocol) do |client|
-              tasks = requests_count.times.map do |index|
-                task.async do
-                  response = client.get "/foo#{index}"
-                  responses[index] = response_to_hash(response)
-                end
-              end
-
-              tasks.map(&:wait)
-            end
-          end
-          responses
-        end
-
-        context 'HTTP1 protocol' do
-          let(:protocol) { Async::HTTP::Protocol::HTTP1 }
-
-          include_examples :common
-        end
-
-        context 'HTTP2 protocol' do
-          let(:protocol) { Async::HTTP::Protocol::HTTP2 }
-
-          include_examples :common
-        end
-      end
-    end
-
-    def make_request(method, url, protocol: nil, headers: {}, body: nil)
-      Async do
-        endpoint = Async::HTTP::Endpoint.parse(url)
-
-        begin
-          Async::HTTP::Client.open(endpoint, protocol || endpoint.protocol) do |client|
-            response = client.send(
-              method,
-              endpoint.path,
-              headers,
-              body
-            )
-            response_to_hash(response)
-          end
-        rescue Async::TimeoutError => e
-          e
-        end
-      end.wait
-    end
-
-    def response_to_hash(response)
-      {
-        status: response.status,
-        headers: response.headers.to_h,
-        body: response.read
-      }
-    end
-  end
-end

data/spec/acceptance/async_http_client/async_http_client_spec_helper.rb

@@ -1,73 +0,0 @@
-module AsyncHttpClientSpecHelper
-  def http_request(method, url, options = {}, &block)
-    endpoint = Async::HTTP::Endpoint.parse(url)
-
-    path = endpoint.path
-    path = path + "?" + options[:query] if options[:query]
-
-    headers = (options[:headers] || {}).each_with_object([]) do |(k, v), o|
-      Array(v).each do |v|
-        o.push [k, v]
-      end
-    end
-    headers.push(
-      ['authorization', 'Basic ' + Base64.strict_encode64(options[:basic_auth].join(':'))]
-    ) if options[:basic_auth]
-
-    body = options[:body]
-
-    Async do
-      begin
-        Async::HTTP::Client.open(endpoint) do |client|
-          response = client.send(
-            method,
-            path,
-            headers,
-            body
-          )
-
-          OpenStruct.new(
-            build_hash_response(response)
-          )
-        end
-      rescue Exception => e
-        e
-      end
-    end.wait
-  end
-
-  def client_timeout_exception_class
-    Async::TimeoutError
-  end
-
-  def connection_refused_exception_class
-    Errno::ECONNREFUSED
-  end
-
-  def http_library
-    :async_http_client
-  end
-
-  private
-
-  def build_hash_response(response)
-    {
-
-      status: response.status.to_s,
-      message: Protocol::HTTP1::Reason::DESCRIPTIONS[response.status],
-      headers: build_response_headers(response),
-      body: response.read
-    }
-  end
-
-  def build_response_headers(response)
-    response.headers.each.each_with_object({}) do |(k, v), o|
-      o[k] ||= []
-      o[k] << v
-    end.tap do |o|
-      o.each do |k, v|
-        o[k] = v.join(', ')
-      end
-    end
-  end
-end