vagrant-unbundled 1.8.4.2 → 1.8.5.1

data/vendor/bundle/ruby/2.3.0/gems/rest-client-2.0.0/spec/unit/_lib.rb

@@ -0,0 +1 @@
+require_relative '../spec_helper'

data/vendor/bundle/ruby/2.3.0/gems/rest-client-2.0.0/spec/unit/abstract_response_spec.rb

@@ -0,0 +1,145 @@
+require_relative '_lib'
+
+describe RestClient::AbstractResponse, :include_helpers do
+
+  class MyAbstractResponse
+
+    include RestClient::AbstractResponse
+
+    attr_accessor :size
+
+    def initialize net_http_res, request
+      @net_http_res = net_http_res
+      @request = request
+    end
+
+  end
+
+  before do
+    @net_http_res = double('net http response')
+    @request = request_double(url: 'http://example.com', method: 'get')
+    @response = MyAbstractResponse.new(@net_http_res, @request)
+  end
+
+  it "fetches the numeric response code" do
+    expect(@net_http_res).to receive(:code).and_return('200')
+    expect(@response.code).to eq 200
+  end
+
+  it "has a nice description" do
+    expect(@net_http_res).to receive(:to_hash).and_return({'Content-Type' => ['application/pdf']})
+    expect(@net_http_res).to receive(:code).and_return('200')
+    expect(@response.description).to eq "200 OK | application/pdf  bytes\n"
+  end
+
+  describe '.beautify_headers' do
+    it "beautifies the headers by turning the keys to symbols" do
+      h = RestClient::AbstractResponse.beautify_headers('content-type' => [ 'x' ])
+      expect(h.keys.first).to eq :content_type
+    end
+
+    it "beautifies the headers by turning the values to strings instead of one-element arrays" do
+      h = RestClient::AbstractResponse.beautify_headers('x' => [ 'text/html' ] )
+      expect(h.values.first).to eq 'text/html'
+    end
+
+    it 'joins multiple header values by comma' do
+      expect(RestClient::AbstractResponse.beautify_headers(
+        {'My-Header' => ['one', 'two']}
+      )).to eq({:my_header => 'one, two'})
+    end
+
+    it 'leaves set-cookie headers as array' do
+      expect(RestClient::AbstractResponse.beautify_headers(
+        {'Set-Cookie' => ['cookie1=foo', 'cookie2=bar']}
+      )).to eq({:set_cookie => ['cookie1=foo', 'cookie2=bar']})
+    end
+  end
+
+  it "fetches the headers" do
+    expect(@net_http_res).to receive(:to_hash).and_return('content-type' => [ 'text/html' ])
+    expect(@response.headers).to eq({ :content_type => 'text/html' })
+  end
+
+  it "extracts cookies from response headers" do
+    expect(@net_http_res).to receive(:to_hash).and_return('set-cookie' => ['session_id=1; path=/'])
+    expect(@response.cookies).to eq({ 'session_id' => '1' })
+  end
+
+  it "extract strange cookies" do
+    expect(@net_http_res).to receive(:to_hash).and_return('set-cookie' => ['session_id=ZJ/HQVH6YE+rVkTpn0zvTQ==; path=/'])
+    expect(@response.headers).to eq({:set_cookie => ['session_id=ZJ/HQVH6YE+rVkTpn0zvTQ==; path=/']})
+    expect(@response.cookies).to eq({ 'session_id' => 'ZJ/HQVH6YE+rVkTpn0zvTQ==' })
+  end
+
+  it "doesn't escape cookies" do
+    expect(@net_http_res).to receive(:to_hash).and_return('set-cookie' => ['session_id=BAh7BzoNYXBwX25hbWUiEGFwcGxpY2F0aW9uOgpsb2dpbiIKYWRtaW4%3D%0A--08114ba654f17c04d20dcc5228ec672508f738ca; path=/'])
+    expect(@response.cookies).to eq({ 'session_id' => 'BAh7BzoNYXBwX25hbWUiEGFwcGxpY2F0aW9uOgpsb2dpbiIKYWRtaW4%3D%0A--08114ba654f17c04d20dcc5228ec672508f738ca' })
+  end
+
+  describe '.cookie_jar' do
+    it 'extracts cookies into cookie jar' do
+      expect(@net_http_res).to receive(:to_hash).and_return('set-cookie' => ['session_id=1; path=/'])
+      expect(@response.cookie_jar).to be_a HTTP::CookieJar
+
+      cookie = @response.cookie_jar.cookies.first
+      expect(cookie.domain).to eq 'example.com'
+      expect(cookie.name).to eq 'session_id'
+      expect(cookie.value).to eq '1'
+      expect(cookie.path).to eq '/'
+    end
+
+    it 'handles cookies when URI scheme is implicit' do
+      net_http_res = double('net http response')
+      expect(net_http_res).to receive(:to_hash).and_return('set-cookie' => ['session_id=1; path=/'])
+      request = double(url: 'example.com', uri: URI.parse('http://example.com'),
+                       method: 'get', cookie_jar: HTTP::CookieJar.new)
+      response = MyAbstractResponse.new(net_http_res, request)
+      expect(response.cookie_jar).to be_a HTTP::CookieJar
+
+      cookie = response.cookie_jar.cookies.first
+      expect(cookie.domain).to eq 'example.com'
+      expect(cookie.name).to eq 'session_id'
+      expect(cookie.value).to eq '1'
+      expect(cookie.path).to eq '/'
+    end
+  end
+
+  it "can access the net http result directly" do
+    expect(@response.net_http_res).to eq @net_http_res
+  end
+
+  describe "#return!" do
+    it "should return the response itself on 200-codes" do
+      expect(@net_http_res).to receive(:code).and_return('200')
+      expect(@response.return!).to be_equal(@response)
+    end
+
+    it "should raise RequestFailed on unknown codes" do
+      expect(@net_http_res).to receive(:code).and_return('1000')
+      expect { @response.return! }.to raise_error RestClient::RequestFailed
+    end
+
+    it "should raise an error on a redirection after non-GET/HEAD requests" do
+      expect(@net_http_res).to receive(:code).and_return('301')
+      expect(@request).to receive(:method).and_return('put')
+      expect(@response).not_to receive(:follow_redirection)
+      expect { @response.return! }.to raise_error RestClient::RequestFailed
+    end
+
+    it "should follow 302 redirect" do
+      expect(@net_http_res).to receive(:code).and_return('302')
+      expect(@response).to receive(:check_max_redirects).and_return('fake-check')
+      expect(@response).to receive(:follow_redirection).and_return('fake-redirection')
+      expect(@response.return!).to eq 'fake-redirection'
+    end
+
+    it "should gracefully handle 302 redirect with no location header" do
+      @net_http_res = response_double(code: 302, location: nil)
+      @request = request_double()
+      @response = MyAbstractResponse.new(@net_http_res, @request)
+      expect(@response).to receive(:check_max_redirects).and_return('fake-check')
+      expect { @response.return! }.to raise_error RestClient::Found
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/rest-client-2.0.0/spec/unit/exceptions_spec.rb

@@ -0,0 +1,108 @@
+require_relative '_lib'
+
+describe RestClient::Exception do
+  it "returns a 'message' equal to the class name if the message is not set, because 'message' should not be nil" do
+    e = RestClient::Exception.new
+    expect(e.message).to eq "RestClient::Exception"
+  end
+
+  it "returns the 'message' that was set" do
+    e = RestClient::Exception.new
+    message = "An explicitly set message"
+    e.message = message
+    expect(e.message).to eq message
+  end
+
+  it "sets the exception message to ErrorMessage" do
+    expect(RestClient::ResourceNotFound.new.message).to eq 'Not Found'
+  end
+
+  it "contains exceptions in RestClient" do
+    expect(RestClient::Unauthorized.new).to be_a_kind_of(RestClient::Exception)
+    expect(RestClient::ServerBrokeConnection.new).to be_a_kind_of(RestClient::Exception)
+  end
+end
+
+describe RestClient::ServerBrokeConnection do
+  it "should have a default message of 'Server broke connection'" do
+    e = RestClient::ServerBrokeConnection.new
+    expect(e.message).to eq 'Server broke connection'
+  end
+end
+
+describe RestClient::RequestFailed do
+  before do
+    @response = double('HTTP Response', :code => '502')
+  end
+
+  it "stores the http response on the exception" do
+    response = "response"
+    begin
+      raise RestClient::RequestFailed, response
+    rescue RestClient::RequestFailed => e
+      expect(e.response).to eq response
+    end
+  end
+
+  it "http_code convenience method for fetching the code as an integer" do
+    expect(RestClient::RequestFailed.new(@response).http_code).to eq 502
+  end
+
+  it "http_body convenience method for fetching the body (decoding when necessary)" do
+    expect(RestClient::RequestFailed.new(@response).http_code).to eq 502
+    expect(RestClient::RequestFailed.new(@response).message).to eq 'HTTP status code 502'
+  end
+
+  it "shows the status code in the message" do
+    expect(RestClient::RequestFailed.new(@response).to_s).to match(/502/)
+  end
+end
+
+describe RestClient::ResourceNotFound do
+  it "also has the http response attached" do
+    response = "response"
+    begin
+      raise RestClient::ResourceNotFound, response
+    rescue RestClient::ResourceNotFound => e
+      expect(e.response).to eq response
+    end
+  end
+
+  it 'stores the body on the response of the exception' do
+    body = "body"
+    stub_request(:get, "www.example.com").to_return(:body => body, :status => 404)
+    begin
+      RestClient.get "www.example.com"
+      raise
+    rescue RestClient::ResourceNotFound => e
+      expect(e.response.body).to eq body
+    end
+  end
+end
+
+describe "backwards compatibility" do
+  it 'aliases RestClient::NotFound as ResourceNotFound' do
+    expect(RestClient::ResourceNotFound).to eq RestClient::NotFound
+  end
+
+  it 'aliases old names for HTTP 413, 414, 416' do
+    expect(RestClient::RequestEntityTooLarge).to eq RestClient::PayloadTooLarge
+    expect(RestClient::RequestURITooLong).to eq RestClient::URITooLong
+    expect(RestClient::RequestedRangeNotSatisfiable).to eq RestClient::RangeNotSatisfiable
+  end
+
+  it 'subclasses NotFound from RequestFailed, ExceptionWithResponse' do
+    expect(RestClient::NotFound).to be < RestClient::RequestFailed
+    expect(RestClient::NotFound).to be < RestClient::ExceptionWithResponse
+  end
+
+  it 'subclasses timeout from RestClient::RequestTimeout, RequestFailed, EWR' do
+    expect(RestClient::Exceptions::OpenTimeout).to be < RestClient::Exceptions::Timeout
+    expect(RestClient::Exceptions::ReadTimeout).to be < RestClient::Exceptions::Timeout
+
+    expect(RestClient::Exceptions::Timeout).to be < RestClient::RequestTimeout
+    expect(RestClient::Exceptions::Timeout).to be < RestClient::RequestFailed
+    expect(RestClient::Exceptions::Timeout).to be < RestClient::ExceptionWithResponse
+  end
+
+end

data/vendor/bundle/ruby/2.3.0/gems/rest-client-2.0.0/spec/unit/params_array_spec.rb

@@ -0,0 +1,36 @@
+require_relative '_lib'
+
+describe RestClient::ParamsArray do
+
+  describe '.new' do
+    it 'accepts various types of containers' do
+      as_array = [[:foo, 123], [:foo, 456], [:bar, 789], [:empty, nil]]
+      [
+        [[:foo, 123], [:foo, 456], [:bar, 789], [:empty, nil]],
+        [{foo: 123}, {foo: 456}, {bar: 789}, {empty: nil}],
+        [{foo: 123}, {foo: 456}, {bar: 789}, {empty: nil}],
+        [{foo: 123}, [:foo, 456], {bar: 789}, {empty: nil}],
+        [{foo: 123}, [:foo, 456], {bar: 789}, [:empty]],
+      ].each do |input|
+        expect(RestClient::ParamsArray.new(input).to_a).to eq as_array
+      end
+
+      expect(RestClient::ParamsArray.new([]).to_a).to eq []
+      expect(RestClient::ParamsArray.new([]).empty?).to eq true
+    end
+
+    it 'rejects various invalid input' do
+      expect {
+        RestClient::ParamsArray.new([[]])
+      }.to raise_error(IndexError)
+
+      expect {
+        RestClient::ParamsArray.new([[1,2,3]])
+      }.to raise_error(ArgumentError)
+
+      expect {
+        RestClient::ParamsArray.new([1,2,3])
+      }.to raise_error(NoMethodError)
+    end
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/rest-client-2.0.0/spec/unit/payload_spec.rb

@@ -0,0 +1,263 @@
+# encoding: binary
+
+require_relative '_lib'
+
+describe RestClient::Payload do
+  context "Base Payload" do
+    it "should reset stream after to_s" do
+      payload = RestClient::Payload::Base.new('foobar')
+      expect(payload.to_s).to eq 'foobar'
+      expect(payload.to_s).to eq 'foobar'
+    end
+  end
+
+  context "A regular Payload" do
+    it "should use standard enctype as default content-type" do
+      expect(RestClient::Payload::UrlEncoded.new({}).headers['Content-Type']).
+        to eq 'application/x-www-form-urlencoded'
+    end
+
+    it "should form properly encoded params" do
+      expect(RestClient::Payload::UrlEncoded.new({:foo => 'bar'}).to_s).
+        to eq "foo=bar"
+      expect(["foo=bar&baz=qux", "baz=qux&foo=bar"]).to include(
+                                                        RestClient::Payload::UrlEncoded.new({:foo => 'bar', :baz => 'qux'}).to_s)
+    end
+
+    it "should escape parameters" do
+      expect(RestClient::Payload::UrlEncoded.new({'foo + bar' => 'baz'}).to_s).
+        to eq "foo+%2B+bar=baz"
+    end
+
+    it "should properly handle hashes as parameter" do
+      expect(RestClient::Payload::UrlEncoded.new({:foo => {:bar => 'baz'}}).to_s).
+        to eq "foo[bar]=baz"
+      expect(RestClient::Payload::UrlEncoded.new({:foo => {:bar => {:baz => 'qux'}}}).to_s).
+        to eq "foo[bar][baz]=qux"
+    end
+
+    it "should handle many attributes inside a hash" do
+      parameters = RestClient::Payload::UrlEncoded.new({:foo => {:bar => 'baz', :baz => 'qux'}}).to_s
+      expect(parameters).to eq 'foo[bar]=baz&foo[baz]=qux'
+    end
+
+    it "should handle attributes inside an array inside an hash" do
+      parameters = RestClient::Payload::UrlEncoded.new({"foo" => [{"bar" => 'baz'}, {"bar" => 'qux'}]}).to_s
+      expect(parameters).to eq 'foo[][bar]=baz&foo[][bar]=qux'
+    end
+
+    it "should handle arrays inside a hash inside a hash" do
+      parameters = RestClient::Payload::UrlEncoded.new({"foo" => {'even' => [0, 2], 'odd' => [1, 3]}}).to_s
+      expect(parameters).to eq 'foo[even][]=0&foo[even][]=2&foo[odd][]=1&foo[odd][]=3'
+    end
+
+    it "should form properly use symbols as parameters" do
+      expect(RestClient::Payload::UrlEncoded.new({:foo => :bar}).to_s).
+        to eq "foo=bar"
+      expect(RestClient::Payload::UrlEncoded.new({:foo => {:bar => :baz}}).to_s).
+        to eq "foo[bar]=baz"
+    end
+
+    it "should properly handle arrays as repeated parameters" do
+      expect(RestClient::Payload::UrlEncoded.new({:foo => ['bar']}).to_s).
+        to eq "foo[]=bar"
+      expect(RestClient::Payload::UrlEncoded.new({:foo => ['bar', 'baz']}).to_s).
+        to eq "foo[]=bar&foo[]=baz"
+    end
+
+    it 'should not close if stream already closed' do
+      p = RestClient::Payload::UrlEncoded.new({'foo ' => 'bar'})
+      3.times {p.close}
+    end
+
+  end
+
+  context "A multipart Payload" do
+    it "should use standard enctype as default content-type" do
+      m = RestClient::Payload::Multipart.new({})
+      allow(m).to receive(:boundary).and_return(123)
+      expect(m.headers['Content-Type']).to eq 'multipart/form-data; boundary=123'
+    end
+
+    it 'should not error on close if stream already closed' do
+      m = RestClient::Payload::Multipart.new(:file => File.new(File.join(File.dirname(File.expand_path(__FILE__)), 'master_shake.jpg')))
+      3.times {m.close}
+    end
+
+    it "should form properly separated multipart data" do
+      m = RestClient::Payload::Multipart.new([[:bar, "baz"], [:foo, "bar"]])
+      expect(m.to_s).to eq <<-EOS
+--#{m.boundary}\r
+Content-Disposition: form-data; name="bar"\r
+\r
+baz\r
+--#{m.boundary}\r
+Content-Disposition: form-data; name="foo"\r
+\r
+bar\r
+--#{m.boundary}--\r
+      EOS
+    end
+
+    it "should not escape parameters names" do
+      m = RestClient::Payload::Multipart.new([["bar ", "baz"]])
+      expect(m.to_s).to eq <<-EOS
+--#{m.boundary}\r
+Content-Disposition: form-data; name="bar "\r
+\r
+baz\r
+--#{m.boundary}--\r
+      EOS
+    end
+
+    it "should form properly separated multipart data" do
+      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      m = RestClient::Payload::Multipart.new({:foo => f})
+      expect(m.to_s).to eq <<-EOS
+--#{m.boundary}\r
+Content-Disposition: form-data; name="foo"; filename="master_shake.jpg"\r
+Content-Type: image/jpeg\r
+\r
+#{File.open(f.path, 'rb'){|bin| bin.read}}\r
+--#{m.boundary}--\r
+      EOS
+    end
+
+    it "should ignore the name attribute when it's not set" do
+      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      m = RestClient::Payload::Multipart.new({nil => f})
+      expect(m.to_s).to eq <<-EOS
+--#{m.boundary}\r
+Content-Disposition: form-data; filename="master_shake.jpg"\r
+Content-Type: image/jpeg\r
+\r
+#{File.open(f.path, 'rb'){|bin| bin.read}}\r
+--#{m.boundary}--\r
+      EOS
+    end
+
+    it "should detect optional (original) content type and filename" do
+      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      f.instance_eval "def content_type; 'text/plain'; end"
+      f.instance_eval "def original_filename; 'foo.txt'; end"
+      m = RestClient::Payload::Multipart.new({:foo => f})
+      expect(m.to_s).to eq <<-EOS
+--#{m.boundary}\r
+Content-Disposition: form-data; name="foo"; filename="foo.txt"\r
+Content-Type: text/plain\r
+\r
+#{File.open(f.path, 'rb'){|bin| bin.read}}\r
+--#{m.boundary}--\r
+      EOS
+    end
+
+    it "should handle hash in hash parameters" do
+      m = RestClient::Payload::Multipart.new({:bar => {:baz => "foo"}})
+      expect(m.to_s).to eq <<-EOS
+--#{m.boundary}\r
+Content-Disposition: form-data; name="bar[baz]"\r
+\r
+foo\r
+--#{m.boundary}--\r
+      EOS
+
+      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      f.instance_eval "def content_type; 'text/plain'; end"
+      f.instance_eval "def original_filename; 'foo.txt'; end"
+      m = RestClient::Payload::Multipart.new({:foo => {:bar => f}})
+      expect(m.to_s).to eq <<-EOS
+--#{m.boundary}\r
+Content-Disposition: form-data; name="foo[bar]"; filename="foo.txt"\r
+Content-Type: text/plain\r
+\r
+#{File.open(f.path, 'rb'){|bin| bin.read}}\r
+--#{m.boundary}--\r
+      EOS
+    end
+
+    it 'should correctly format hex boundary' do
+      allow(SecureRandom).to receive(:base64).with(12).and_return('TGs89+ttw/xna6TV')
+      f = File.new(File.dirname(__FILE__) + '/master_shake.jpg')
+      m = RestClient::Payload::Multipart.new({:foo => f})
+      expect(m.boundary).to eq('-' * 4 + 'RubyFormBoundary' + 'TGs89AttwBxna6TV')
+    end
+
+  end
+
+  context "streamed payloads" do
+    it "should properly determine the size of file payloads" do
+      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      payload = RestClient::Payload.generate(f)
+      expect(payload.size).to eq 76_988
+      expect(payload.length).to eq 76_988
+    end
+
+    it "should properly determine the size of other kinds of streaming payloads" do
+      s = StringIO.new 'foo'
+      payload = RestClient::Payload.generate(s)
+      expect(payload.size).to eq 3
+      expect(payload.length).to eq 3
+
+      begin
+        f = Tempfile.new "rest-client"
+        f.write 'foo bar'
+
+        payload = RestClient::Payload.generate(f)
+        expect(payload.size).to eq 7
+        expect(payload.length).to eq 7
+      ensure
+        f.close
+      end
+    end
+  end
+
+  context "Payload generation" do
+    it "should recognize standard urlencoded params" do
+      expect(RestClient::Payload.generate({"foo" => 'bar'})).to be_kind_of(RestClient::Payload::UrlEncoded)
+    end
+
+    it "should recognize multipart params" do
+      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      expect(RestClient::Payload.generate({"foo" => f})).to be_kind_of(RestClient::Payload::Multipart)
+    end
+
+    it "should be multipart if forced" do
+      expect(RestClient::Payload.generate({"foo" => "bar", :multipart => true})).to be_kind_of(RestClient::Payload::Multipart)
+    end
+
+    it "should handle deeply nested multipart" do
+      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      params = {foo: RestClient::ParamsArray.new({nested: f})}
+      expect(RestClient::Payload.generate(params)).to be_kind_of(RestClient::Payload::Multipart)
+    end
+
+
+    it "should return data if no of the above" do
+      expect(RestClient::Payload.generate("data")).to be_kind_of(RestClient::Payload::Base)
+    end
+
+    it "should recognize nested multipart payloads in hashes" do
+      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      expect(RestClient::Payload.generate({"foo" => {"file" => f}})).to be_kind_of(RestClient::Payload::Multipart)
+    end
+
+    it "should recognize nested multipart payloads in arrays" do
+      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      expect(RestClient::Payload.generate({"foo" => [f]})).to be_kind_of(RestClient::Payload::Multipart)
+    end
+
+    it "should recognize file payloads that can be streamed" do
+      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      expect(RestClient::Payload.generate(f)).to be_kind_of(RestClient::Payload::Streamed)
+    end
+
+    it "should recognize other payloads that can be streamed" do
+      expect(RestClient::Payload.generate(StringIO.new('foo'))).to be_kind_of(RestClient::Payload::Streamed)
+    end
+
+    # hashery gem introduces Hash#read convenience method. Existence of #read method used to determine of content is streameable :/
+    it "shouldn't treat hashes as streameable" do
+      expect(RestClient::Payload.generate({"foo" => 'bar'})).to be_kind_of(RestClient::Payload::UrlEncoded)
+    end
+  end
+end