rest-man 1.0.0 → 1.1.0

data/spec/unit/request_spec.rb

@@ -20,6 +20,10 @@ describe RestMan::Request, :include_helpers do
     allow(@net).to receive(:verify_callback=)
     allow(@net).to receive(:ciphers=)
     allow(@net).to receive(:cert_store=)
+    allow(@net).to receive(:max_retries=)
+    allow(@net).to receive(:read_timeout=)
+    allow(@net).to receive(:write_timeout=)
+    allow(@net).to receive(:open_timeout=)
     RestMan.log = nil
   end
 
@@ -46,48 +50,17 @@ describe RestMan::Request, :include_helpers do
     end
   end
 
-  describe '.normalize_url' do
-    it "adds http:// to the front of resources specified in the syntax example.com/resource" do
-      expect(@request.normalize_url('example.com/resource')).to eq 'http://example.com/resource'
-    end
-
-    it 'adds http:// to resources containing a colon' do
-      expect(@request.normalize_url('example.com:1234')).to eq 'http://example.com:1234'
-    end
-
-    it 'does not add http:// to the front of https resources' do
-      expect(@request.normalize_url('https://example.com/resource')).to eq 'https://example.com/resource'
-    end
-
-    it 'does not add http:// to the front of capital HTTP resources' do
-      expect(@request.normalize_url('HTTP://example.com/resource')).to eq 'HTTP://example.com/resource'
-    end
-
-    it 'does not add http:// to the front of capital HTTPS resources' do
-      expect(@request.normalize_url('HTTPS://example.com/resource')).to eq 'HTTPS://example.com/resource'
-    end
-
-    it 'raises with invalid URI' do
-      expect {
-        RestMan::Request.new(method: :get, url: 'http://a@b:c')
-      }.to raise_error(URI::InvalidURIError)
-      expect {
-        RestMan::Request.new(method: :get, url: 'http://::')
-      }.to raise_error(URI::InvalidURIError)
-    end
-  end
-
   describe "user - password" do
     it "extracts the username and password when parsing http://user:password@example.com/" do
-      @request.send(:parse_url_with_auth!, 'http://joe:pass1@example.com/resource')
-      expect(@request.user).to eq 'joe'
-      expect(@request.password).to eq 'pass1'
+      request = RestMan::Request.new(method: :get, url: 'http://joe:pass1@example.com/resource')
+      expect(request.user).to eq 'joe'
+      expect(request.password).to eq 'pass1'
     end
 
     it "extracts with escaping the username and password when parsing http://user:password@example.com/" do
-      @request.send(:parse_url_with_auth!, 'http://joe%20:pass1@example.com/resource')
-      expect(@request.user).to eq 'joe '
-      expect(@request.password).to eq 'pass1'
+      request = RestMan::Request.new(method: :get, url: 'http://joe%20:pass1@example.com/resource')
+      expect(request.user).to eq 'joe '
+      expect(request.password).to eq 'pass1'
     end
 
     it "doesn't overwrite user and password (which may have already been set by the Resource constructor) if there is no user/password in the url" do
@@ -236,31 +209,14 @@ describe RestMan::Request, :include_helpers do
     end
   end
 
-  it 'warns when overriding existing headers via payload' do
-    expect(fake_stderr {
-      RestMan::Request.new(method: :post, url: 'example.com',
-                              payload: {'foo' => 1}, headers: {content_type: :json})
-    }).to match(/warning: Overriding "Content-Type" header/i)
-    expect(fake_stderr {
-      RestMan::Request.new(method: :post, url: 'example.com',
-                              payload: {'foo' => 1}, headers: {'Content-Type' => 'application/json'})
-    }).to match(/warning: Overriding "Content-Type" header/i)
-
-    expect(fake_stderr {
-      RestMan::Request.new(method: :post, url: 'example.com',
-                              payload: '123456', headers: {content_length: '20'})
-    }).to match(/warning: Overriding "Content-Length" header/i)
-    expect(fake_stderr {
-      RestMan::Request.new(method: :post, url: 'example.com',
-                              payload: '123456', headers: {'Content-Length' => '20'})
-    }).to match(/warning: Overriding "Content-Length" header/i)
-  end
-
-  it "does not warn when overriding user header with header derived from payload if those header values were identical" do
-    expect(fake_stderr {
-      RestMan::Request.new(method: :post, url: 'example.com',
-                              payload: {'foo' => '123456'}, headers: { 'Content-Type' => 'application/x-www-form-urlencoded' })
-    }).not_to match(/warning: Overriding "Content-Type" header/i)
+  it "does not override headers" do
+    request = RestMan::Request.new(
+      method: :post,
+      url: 'example.com',
+      payload: {'foo' => '123456'},
+      headers: { 'Content-Type' => 'application/x-www-form-urlencoded; charset=UTF-8' }
+    )
+    expect(request.processed_headers['Content-Type']).to eq('application/x-www-form-urlencoded; charset=UTF-8')
   end
 
   it 'does not warn for a normal looking payload' do
@@ -488,6 +444,12 @@ describe RestMan::Request, :include_helpers do
     expect { @request.send(:transmit, @uri, 'req', nil) }.to raise_error(RestMan::Exceptions::OpenTimeout)
   end
 
+  it "catches Net::WriteTimeout and raises RestMan's WriteTimeout",
+     :if => defined?(Net::WriteTimeout) do
+    allow(@http).to receive(:request).and_raise(Net::WriteTimeout)
+    expect { @request.send(:transmit, @uri, 'req', nil) }.to raise_error(RestMan::Exceptions::WriteTimeout)
+  end
+
   it "uses correct error message for ReadTimeout",
      :if => defined?(Net::ReadTimeout) do
     allow(@http).to receive(:request).and_raise(Net::ReadTimeout)
@@ -500,6 +462,11 @@ describe RestMan::Request, :include_helpers do
     expect { @request.send(:transmit, @uri, 'req', nil) }.to raise_error(RestMan::Exceptions::OpenTimeout, 'Timed out connecting to server')
   end
 
+  it "uses correct error message for WriteTimeout",
+     :if => defined?(Net::WriteTimeout) do
+    allow(@http).to receive(:request).and_raise(Net::WriteTimeout)
+    expect { @request.send(:transmit, @uri, 'req', nil) }.to raise_error(RestMan::Exceptions::WriteTimeout, 'Timed out writing data to server')
+  end
 
   it "class method execute wraps constructor" do
     req = double("rest request")
@@ -690,17 +657,6 @@ describe RestMan::Request, :include_helpers do
   end
 
   describe "timeout" do
-    it "does not set timeouts if not specified" do
-      @request = RestMan::Request.new(:method => :put, :url => 'http://some/resource', :payload => 'payload')
-      allow(@http).to receive(:request)
-      allow(@request).to receive(:process_result)
-
-      expect(@net).not_to receive(:read_timeout=)
-      expect(@net).not_to receive(:open_timeout=)
-
-      @request.send(:transmit, @uri, 'req', nil)
-    end
-
     it 'sets read_timeout' do
       @request = RestMan::Request.new(:method => :put, :url => 'http://some/resource', :payload => 'payload', :read_timeout => 123)
       allow(@http).to receive(:request)
@@ -721,62 +677,49 @@ describe RestMan::Request, :include_helpers do
       @request.send(:transmit, @uri, 'req', nil)
     end
 
-    it 'sets both timeouts with :timeout' do
-      @request = RestMan::Request.new(:method => :put, :url => 'http://some/resource', :payload => 'payload', :timeout => 123)
+    it "sets write_timeout" do
+      @request = RestMan::Request.new(:method => :put, :url => 'http://some/resource', :payload => 'payload', :write_timeout => 123)
       allow(@http).to receive(:request)
       allow(@request).to receive(:process_result)
 
-      expect(@net).to receive(:open_timeout=).with(123)
-      expect(@net).to receive(:read_timeout=).with(123)
+      expect(@net).to receive(:write_timeout=).with(123)
 
       @request.send(:transmit, @uri, 'req', nil)
     end
 
-    it 'supersedes :timeout with open/read_timeout' do
-      @request = RestMan::Request.new(:method => :put, :url => 'http://some/resource', :payload => 'payload', :timeout => 123, :open_timeout => 34, :read_timeout => 56)
+    it 'sets all timeouts with :timeout' do
+      @request = RestMan::Request.new(:method => :put, :url => 'http://some/resource', :payload => 'payload', :timeout => 123)
       allow(@http).to receive(:request)
       allow(@request).to receive(:process_result)
 
-      expect(@net).to receive(:open_timeout=).with(34)
-      expect(@net).to receive(:read_timeout=).with(56)
+      expect(@net).to receive(:open_timeout=).with(123)
+      expect(@net).to receive(:read_timeout=).with(123)
+      expect(@net).to receive(:write_timeout=).with(123)
 
       @request.send(:transmit, @uri, 'req', nil)
     end
 
-
-    it "disable timeout by setting it to nil" do
-      @request = RestMan::Request.new(:method => :put, :url => 'http://some/resource', :payload => 'payload', :read_timeout => nil, :open_timeout => nil)
+    it 'supersedes :timeout with open/read/write_timeout' do
+      @request = RestMan::Request.new(:method => :put, :url => 'http://some/resource', :payload => 'payload', :timeout => 123, :open_timeout => 34, :read_timeout => 56, :write_timeout => 78)
       allow(@http).to receive(:request)
       allow(@request).to receive(:process_result)
 
-      expect(@net).to receive(:read_timeout=).with(nil)
-      expect(@net).to receive(:open_timeout=).with(nil)
+      expect(@net).to receive(:open_timeout=).with(34)
+      expect(@net).to receive(:read_timeout=).with(56)
+      expect(@net).to receive(:write_timeout=).with(78)
 
       @request.send(:transmit, @uri, 'req', nil)
     end
 
-    it 'deprecated: warns when disabling timeout by setting it to -1' do
-      @request = RestMan::Request.new(:method => :put, :url => 'http://some/resource', :payload => 'payload', :read_timeout => -1)
-      allow(@http).to receive(:request)
-      allow(@request).to receive(:process_result)
-
-      expect(@net).to receive(:read_timeout=).with(nil)
-
-      expect(fake_stderr {
-        @request.send(:transmit, @uri, 'req', nil)
-      }).to match(/^Deprecated: .*timeout.* nil instead of -1$/)
-    end
 
-    it "deprecated: disable timeout by setting it to -1" do
-      @request = RestMan::Request.new(:method => :put, :url => 'http://some/resource', :payload => 'payload', :read_timeout => -1, :open_timeout => -1)
+    it "disable timeout by setting it to nil" do
+      @request = RestMan::Request.new(:method => :put, :url => 'http://some/resource', :payload => 'payload', :read_timeout => nil, :open_timeout => nil, :write_timeout => nil)
       allow(@http).to receive(:request)
       allow(@request).to receive(:process_result)
 
-      expect(@request).to receive(:warn)
       expect(@net).to receive(:read_timeout=).with(nil)
-
-      expect(@request).to receive(:warn)
       expect(@net).to receive(:open_timeout=).with(nil)
+      expect(@net).to receive(:write_timeout=).with(nil)
 
       @request.send(:transmit, @uri, 'req', nil)
     end
@@ -844,6 +787,58 @@ describe RestMan::Request, :include_helpers do
       @request.send(:transmit, @uri, 'req', 'payload')
     end
 
+    it "should set the keep_alive_timeout if provided" do
+      @request = RestMan::Request.new(
+        :method => :put,
+        :url => 'https://some/resource',
+        :payload => 'payload',
+        :keep_alive_timeout => 1
+      )
+      expect(@net).to receive(:keep_alive_timeout=).with(1)
+      allow(@http).to receive(:request)
+      allow(@request).to receive(:process_result)
+      @request.send(:transmit, @uri, 'req', 'payload')
+    end
+
+    it "should set the close_on_empty_response if provided" do
+      @request = RestMan::Request.new(
+        :method => :put,
+        :url => 'https://some/resource',
+        :payload => 'payload',
+        :close_on_empty_response => true
+      )
+      expect(@net).to receive(:close_on_empty_response=).with(true)
+      allow(@http).to receive(:request)
+      allow(@request).to receive(:process_result)
+      @request.send(:transmit, @uri, 'req', 'payload')
+    end
+
+    it "should set the local_host if provided" do
+      @request = RestMan::Request.new(
+        :method => :put,
+        :url => 'https://some/resource',
+        :payload => 'payload',
+        :local_host => 'localhost'
+      )
+      expect(@net).to receive(:local_host=).with('localhost')
+      allow(@http).to receive(:request)
+      allow(@request).to receive(:process_result)
+      @request.send(:transmit, @uri, 'req', 'payload')
+    end
+
+    it "should set the local_port if provided" do
+      @request = RestMan::Request.new(
+        :method => :put,
+        :url => 'https://some/resource',
+        :payload => 'payload',
+        :local_port => 3000
+      )
+      expect(@net).to receive(:local_port=).with(3000)
+      allow(@http).to receive(:request)
+      allow(@request).to receive(:process_result)
+      @request.send(:transmit, @uri, 'req', 'payload')
+    end
+
     it "should default to not having an ssl_client_cert" do
       expect(@request.ssl_client_cert).to be(nil)
     end
@@ -873,6 +868,45 @@ describe RestMan::Request, :include_helpers do
       @request.send(:transmit, @uri, 'req', 'payload')
     end
 
+    it "should set the ssl_min_version if provided" do
+      @request = RestMan::Request.new(
+        :method => :put,
+        :url => 'https://some/resource',
+        :payload => 'payload',
+        :ssl_min_version => :TLS1_2
+      )
+      expect(@net).to receive(:min_version=).with(:TLS1_2)
+      allow(@http).to receive(:request)
+      allow(@request).to receive(:process_result)
+      @request.send(:transmit, @uri, 'req', 'payload')
+    end
+
+    it "should set the ssl_max_version if provided" do
+      @request = RestMan::Request.new(
+        :method => :put,
+        :url => 'https://some/resource',
+        :payload => 'payload',
+        :ssl_max_version => :TLS1_2
+      )
+      expect(@net).to receive(:max_version=).with(:TLS1_2)
+      allow(@http).to receive(:request)
+      allow(@request).to receive(:process_result)
+      @request.send(:transmit, @uri, 'req', 'payload')
+    end
+
+    it "should set the ssl_timeout if provided" do
+      @request = RestMan::Request.new(
+        :method => :put,
+        :url => 'https://some/resource',
+        :payload => 'payload',
+        :ssl_timeout => 1
+      )
+      expect(@net).to receive(:ssl_timeout=).with(1)
+      allow(@http).to receive(:request)
+      allow(@request).to receive(:process_result)
+      @request.send(:transmit, @uri, 'req', 'payload')
+    end
+
     it "should set the ssl_ciphers if provided" do
       ciphers = 'AESGCM:HIGH:!aNULL:!eNULL:RC4+RSA'
       @request = RestMan::Request.new(
@@ -1150,56 +1184,14 @@ describe RestMan::Request, :include_helpers do
     end
   end
 
-  describe 'constructor' do
-    it 'should reject valid URIs with no hostname' do
-      expect(URI.parse('http:///').hostname).to be_nil
-
-      expect {
-        RestMan::Request.new(method: :get, url: 'http:///')
-      }.to raise_error(URI::InvalidURIError, /\Abad URI/)
-    end
+  it 'raises with invalid URI' do
+    expect {
+      RestMan::Request.new(method: :get, url: 'http://a@b:c')
+    }.to raise_error(URI::InvalidURIError)
 
-    it 'should reject invalid URIs' do
-      expect {
-        RestMan::Request.new(method: :get, url: 'http://::')
-      }.to raise_error(URI::InvalidURIError)
-    end
+    expect {
+      RestMan::Request.new(method: :get, url: 'http://::')
+    }.to raise_error(URI::InvalidURIError)
   end
 
-  describe 'process_url_params' do
-    it 'should handle basic URL params' do
-      expect(@request.process_url_params('https://example.com/foo', params: {key1: 123, key2: 'abc'})).
-        to eq 'https://example.com/foo?key1=123&key2=abc'
-
-      expect(@request.process_url_params('https://example.com/foo', params: {'key1' => 123})).
-        to eq 'https://example.com/foo?key1=123'
-
-      expect(@request.process_url_params('https://example.com/path',
-                                  params: {foo: 'one two', bar: 'three + four == seven'})).
-        to eq 'https://example.com/path?foo=one+two&bar=three+%2B+four+%3D%3D+seven'
-    end
-
-    it 'should combine with & when URL params already exist' do
-      expect(@request.process_url_params('https://example.com/path?foo=1', params: {bar: 2})).
-        to eq 'https://example.com/path?foo=1&bar=2'
-    end
-
-    it 'should handle complex nested URL params per Rack / Rails conventions' do
-      expect(@request.process_url_params('https://example.com/', params: {
-        foo: [1,2,3],
-        null: nil,
-        falsy: false,
-        math: '2+2=4',
-        nested: {'key + escaped' => 'value + escaped', other: [], arr: [1,2]},
-      })).to eq 'https://example.com/?foo[]=1&foo[]=2&foo[]=3&null&falsy=false&math=2%2B2%3D4' \
-                   '&nested[key+%2B+escaped]=value+%2B+escaped&nested[other]' \
-                   '&nested[arr][]=1&nested[arr][]=2'
-    end
-
-    it 'should handle ParamsArray objects' do
-      expect(@request.process_url_params('https://example.com/',
-        params: RestMan::ParamsArray.new([[:foo, 1], [:foo, 2]])
-      )).to eq 'https://example.com/?foo=1&foo=2'
-    end
-  end
 end

data/spec/unit/utils_spec.rb

@@ -1,147 +1,139 @@
 require_relative '_lib'
 
 describe RestMan::Utils do
+
   describe '.get_encoding_from_headers' do
-    it 'assumes no encoding by default for text' do
-      headers = {:content_type => 'text/plain'}
-      expect(RestMan::Utils.get_encoding_from_headers(headers)).
-        to eq nil
-    end
-
-    it 'returns nil on failures' do
-      expect(RestMan::Utils.get_encoding_from_headers(
-        {:content_type => 'blah'})).to eq nil
-      expect(RestMan::Utils.get_encoding_from_headers(
-        {})).to eq nil
-      expect(RestMan::Utils.get_encoding_from_headers(
-        {:content_type => 'foo; bar=baz'})).to eq nil
-    end
-
-    it 'handles various charsets' do
-      expect(RestMan::Utils.get_encoding_from_headers(
-        {:content_type => 'text/plain; charset=UTF-8'})).to eq 'UTF-8'
-      expect(RestMan::Utils.get_encoding_from_headers(
-        {:content_type => 'application/json; charset=ISO-8859-1'})).
-        to eq 'ISO-8859-1'
-      expect(RestMan::Utils.get_encoding_from_headers(
-        {:content_type => 'text/html; charset=windows-1251'})).
-        to eq 'windows-1251'
-
-      expect(RestMan::Utils.get_encoding_from_headers(
-        {:content_type => 'text/html; charset="UTF-16"'})).
-        to eq 'UTF-16'
+
+    let(:get_encoding_from_headers) { RestMan::Utils.get_encoding_from_headers(headers) }
+
+    context 'with valid content_type' do
+      let(:headers) {{content_type: 'text/plain'}}
+
+      it 'assumes no encoding by default' do
+        expect(get_encoding_from_headers).to eq(nil)
+      end
     end
-  end
 
-  describe '.cgi_parse_header' do
-    it 'parses headers', :unless => RUBY_VERSION.start_with?('2.0') do
-      expect(RestMan::Utils.cgi_parse_header('text/plain')).
-        to eq ['text/plain', {}]
+    context 'with invalid content_type like "blah"' do
+      let(:headers) {{content_type: 'blah'}}
 
-      expect(RestMan::Utils.cgi_parse_header('text/vnd.just.made.this.up')).
-        to eq ['text/vnd.just.made.this.up', {}]
+      it 'return nil' do
+        expect(get_encoding_from_headers).to eq(nil)
+      end
+    end
 
-      expect(RestMan::Utils.cgi_parse_header('text/plain;charset=us-ascii')).
-        to eq ['text/plain', {'charset' => 'us-ascii'}]
+    context 'with invalid content_type like "foo; bar=baz"' do
+      let(:headers) {{content_type: 'foo; bar=baz'}}
 
-      expect(RestMan::Utils.cgi_parse_header('text/plain ; charset="us-ascii"')).
-        to eq ['text/plain', {'charset' => 'us-ascii'}]
+      it 'return nil' do
+        expect(get_encoding_from_headers).to eq(nil)
+      end
+    end
 
-      expect(RestMan::Utils.cgi_parse_header(
-        'text/plain ; charset="us-ascii"; another=opt')).
-        to eq ['text/plain', {'charset' => 'us-ascii', 'another' => 'opt'}]
+    context 'with invalid content_type like empty headers' do
+      let(:headers) {{}}
 
-      expect(RestMan::Utils.cgi_parse_header(
-        'foo/bar; filename="silly.txt"')).
-        to eq ['foo/bar', {'filename' => 'silly.txt'}]
+      it 'return nil' do
+        expect(get_encoding_from_headers).to eq(nil)
+      end
+    end
+
+    context 'with valid content_type with charset UTF-8' do
+      let(:headers) {{content_type: 'text/plain; charset=UTF-8'}}
+
+      it 'return UTF-8' do
+        expect(get_encoding_from_headers).to eq('UTF-8')
+      end
+    end
 
-      expect(RestMan::Utils.cgi_parse_header(
-        'foo/bar; filename="strange;name"')).
-        to eq ['foo/bar', {'filename' => 'strange;name'}]
+    context 'with valid content_type with charset ISO-8859-1' do
+      let(:headers) {{content_type: 'text/plain; charset=ISO-8859-1'}}
 
-      expect(RestMan::Utils.cgi_parse_header(
-        'foo/bar; filename="strange;name";size=123')).to eq \
-        ['foo/bar', {'filename' => 'strange;name', 'size' => '123'}]
+      it 'return ISO-8859-1' do
+        expect(get_encoding_from_headers).to eq('ISO-8859-1')
+      end
+    end
 
-      expect(RestMan::Utils.cgi_parse_header(
-        'foo/bar; name="files"; filename="fo\\"o;bar"')).to eq \
-        ['foo/bar', {'name' => 'files', 'filename' => 'fo"o;bar'}]
+    context 'with valid content_type with charset windows-1251' do
+      let(:headers) {{content_type: 'text/plain; charset=windows-1251'}}
+
+      it 'return windows-1251' do
+        expect(get_encoding_from_headers).to eq('windows-1251')
+      end
     end
+
+    context 'with valid content_type with charset UTF-16' do
+      let(:headers) {{content_type: 'text/plain; charset=UTF-16'}}
+
+      it 'return UTF-16' do
+        expect(get_encoding_from_headers).to eq('UTF-16')
+      end
+    end
+
+  end
+
+  describe '.cgi_parse_header' do
+
+    let(:parse) { ->(line, to:) {
+      expect(RestMan::Utils.cgi_parse_header(line)).to eq(to)
+    }}
+
+    it { parse.('text/plain',                                   to: ['text/plain', {}]) }
+    it { parse.('text/vnd.just.made.this.up',                   to: ['text/vnd.just.made.this.up', {}]) }
+    it { parse.('text/plain;charset=us-ascii',                  to: ['text/plain', {'charset' => 'us-ascii'}]) }
+    it { parse.('text/plain ; charset="us-ascii"',              to: ['text/plain', {'charset' => 'us-ascii'}]) }
+    it { parse.('text/plain ; charset="us-ascii"; another=opt', to: ['text/plain', {'charset' => 'us-ascii', 'another' => 'opt'}]) }
+    it { parse.('foo/bar; filename="silly.txt"',                to: ['foo/bar', {'filename' => 'silly.txt'}]) }
+    it { parse.('foo/bar; filename="strange;name"',             to: ['foo/bar', {'filename' => 'strange;name'}]) }
+    it { parse.('foo/bar; filename="strange;name";size=123',    to: ['foo/bar', {'filename' => 'strange;name', 'size' => '123'}]) }
+    it { parse.('foo/bar; name="files"; filename="fo\\"o;bar"', to: ['foo/bar', {'name' => 'files', 'filename' => 'fo"o;bar'}]) }
+
   end
 
   describe '.encode_query_string' do
+    let(:encoding) { -> (input, to:) {
+      expect(RestMan::Utils.encode_query_string(input)).to eq to
+    } }
+
     it 'handles simple hashes' do
-      {
-        {foo: 123, bar: 456} => 'foo=123&bar=456',
-        {'foo' => 123, 'bar' => 456} => 'foo=123&bar=456',
-        {foo: 'abc', bar: 'one two'} => 'foo=abc&bar=one+two',
-        {escaped: '1+2=3'} => 'escaped=1%2B2%3D3',
-        {'escaped + key' => 'foo'} => 'escaped+%2B+key=foo',
-      }.each_pair do |input, expected|
-        expect(RestMan::Utils.encode_query_string(input)).to eq expected
-      end
+      encoding.({foo: 123, bar: 456},         to: 'foo=123&bar=456')
+      encoding.({'foo' => 123, 'bar' => 456}, to: 'foo=123&bar=456')
+      encoding.({foo: 'abc', bar: 'one two'}, to: 'foo=abc&bar=one+two')
+      encoding.({escaped: '1+2=3'},           to: 'escaped=1%2B2%3D3')
+      encoding.({'escaped + key' => 'foo'},   to: 'escaped+%2B+key=foo')
     end
 
     it 'handles simple arrays' do
-      {
-        {foo: [1, 2, 3]} => 'foo[]=1&foo[]=2&foo[]=3',
-        {foo: %w{a b c}, bar: [1, 2, 3]} => 'foo[]=a&foo[]=b&foo[]=c&bar[]=1&bar[]=2&bar[]=3',
-        {foo: ['one two', 3]} => 'foo[]=one+two&foo[]=3',
-        {'a+b' => [1,2,3]} => 'a%2Bb[]=1&a%2Bb[]=2&a%2Bb[]=3',
-      }.each_pair do |input, expected|
-        expect(RestMan::Utils.encode_query_string(input)).to eq expected
-      end
+      encoding.({foo: [1, 2, 3]},                 to: 'foo[]=1&foo[]=2&foo[]=3')
+      encoding.({foo: %w{a b c}, bar: [1, 2, 3]}, to: 'foo[]=a&foo[]=b&foo[]=c&bar[]=1&bar[]=2&bar[]=3')
+      encoding.({foo: ['one two', 3]},            to: 'foo[]=one+two&foo[]=3')
+      encoding.({'a+b' => [1,2,3]},               to: 'a%2Bb[]=1&a%2Bb[]=2&a%2Bb[]=3')
     end
 
     it 'handles nested hashes' do
-      {
-        {outer: {foo: 123, bar: 456}} => 'outer[foo]=123&outer[bar]=456',
-        {outer: {foo: [1, 2, 3], bar: 'baz'}} => 'outer[foo][]=1&outer[foo][]=2&outer[foo][]=3&outer[bar]=baz',
-      }.each_pair do |input, expected|
-        expect(RestMan::Utils.encode_query_string(input)).to eq expected
-      end
+      encoding.({outer: {foo: 123, bar: 456}},         to: 'outer[foo]=123&outer[bar]=456')
+      encoding.({outer: {foo: [1, 2, 3], bar: 'baz'}}, to: 'outer[foo][]=1&outer[foo][]=2&outer[foo][]=3&outer[bar]=baz')
     end
 
     it 'handles null and empty values' do
-      {
-        {string: '', empty: nil, list: [], hash: {}, falsey: false } =>
-          'string=&empty&list&hash&falsey=false',
-      }.each_pair do |input, expected|
-        expect(RestMan::Utils.encode_query_string(input)).to eq expected
-      end
+      encoding.({string: '', empty: nil, list: [], hash: {}, falsey: false }, to: 'string=&empty&list&hash&falsey=false')
     end
 
     it 'handles nested nulls' do
-      {
-        {foo: {string: '', empty: nil}} => 'foo[string]=&foo[empty]',
-      }.each_pair do |input, expected|
-        expect(RestMan::Utils.encode_query_string(input)).to eq expected
-      end
+      encoding.({foo: {string: '', empty: nil}}, to: 'foo[string]=&foo[empty]')
     end
 
     it 'handles deep nesting' do
-      {
-        {coords: [{x: 1, y: 0}, {x: 2}, {x: 3}]} => 'coords[][x]=1&coords[][y]=0&coords[][x]=2&coords[][x]=3',
-      }.each_pair do |input, expected|
-        expect(RestMan::Utils.encode_query_string(input)).to eq expected
-      end
+      encoding.({coords: [{x: 1, y: 0}, {x: 2}, {x: 3}]}, to: 'coords[][x]=1&coords[][y]=0&coords[][x]=2&coords[][x]=3')
     end
 
     it 'handles multiple fields with the same name using ParamsArray' do
-      {
-        RestMan::ParamsArray.new([[:foo, 1], [:foo, 2], [:foo, 3]]) => 'foo=1&foo=2&foo=3',
-      }.each_pair do |input, expected|
-        expect(RestMan::Utils.encode_query_string(input)).to eq expected
-      end
+      encoding.(RestMan::ParamsArray.new([[:foo, 1], [:foo, 2], [:foo, 3]]), to: 'foo=1&foo=2&foo=3')
     end
 
     it 'handles nested ParamsArrays' do
-      {
-        {foo: RestMan::ParamsArray.new([[:a, 1], [:a, 2]])} => 'foo[a]=1&foo[a]=2',
-        RestMan::ParamsArray.new([[:foo, {a: 1}], [:foo, {a: 2}]]) => 'foo[a]=1&foo[a]=2',
-      }.each_pair do |input, expected|
-        expect(RestMan::Utils.encode_query_string(input)).to eq expected
-      end
+      encoding.({foo: RestMan::ParamsArray.new([[:a, 1], [:a, 2]])},        to: 'foo[a]=1&foo[a]=2')
+      encoding.(RestMan::ParamsArray.new([[:foo, {a: 1}], [:foo, {a: 2}]]), to: 'foo[a]=1&foo[a]=2')
     end
   end
 end