aws-sdk-core 2.0.0.rc1

data/vendor/seahorse/spec/seahorse/client/http/headers_spec.rb

@@ -0,0 +1,213 @@
+require 'spec_helper'
+
+module Seahorse
+  module Client
+    module Http
+      describe Headers do
+
+        let(:headers) { Headers.new }
+
+        it 'provides indifferent access to symbolized keys' do
+          headers[:key] = 'value'
+          expect(headers[:key]).to eq('value')
+          expect(headers['key']).to eq('value')
+        end
+
+        it 'provides indifferent access to string keys' do
+          headers['key'] = 'value'
+          expect(headers['key']).to eq('value')
+          expect(headers[:key]).to eq('value')
+        end
+
+        it 'provides case-insenitive access to keys' do
+          headers['Content-Length'] = 100
+          expect(headers['content-length']).to eq('100')
+        end
+
+        it 'stringifies values' do
+          headers['key'] = 123
+          expect(headers['key']).to eq('123')
+        end
+
+        it 'can be seeded by the constructor' do
+          hash = { 'abc' => '123' }
+          headers = Headers.new(hash)
+          expect(headers.to_hash).to eq(hash)
+        end
+
+        describe '#to_hash' do
+
+          it 'returns a regular hash' do
+            headers[:abc] = 'xyz'
+            expect(headers.to_hash).to eq({ 'abc' => 'xyz' })
+          end
+
+          it 'is aliased as #to_h' do
+            headers[:abc] = 'xyz'
+            expect(headers.to_h).to eq({ 'abc' => 'xyz' })
+          end
+
+          it 'returns a new hash that protects internal state' do
+            headers['abc'] = 'xyz'
+            headers.to_hash['abc'] = 'mno'
+            expect(headers['abc']).to eq('xyz')
+          end
+
+        end
+
+        describe '#update' do
+
+          it 'accepts a hash, updating self' do
+            headers.update(:abc => 123, 'xyz' => '234')
+            expect(headers['abc']).to eq('123')
+            expect(headers['xyz']).to eq('234')
+          end
+
+        end
+
+        describe '#each' do
+
+          it 'is enumerable' do
+            expect(headers).to be_kind_of(Enumerable)
+          end
+
+          it 'returns nil if a block is given' do
+            ret = headers.each {}
+            expect(ret).to eq(nil)
+          end
+
+          it 'returns an Enumerator if a block is not given' do
+            expect(headers.each).to be_kind_of(Enumerator)
+          end
+
+          it 'yields headers keys and values' do
+            headers['key1'] = 'value1'
+            headers['key2'] = 'value2'
+            yielded = []
+            headers.each do |key, value|
+              yielded << [key, value]
+            end
+            expect(yielded.sort_by(&:first)).to eq([
+              ['key1', 'value1'],
+              ['key2', 'value2'],
+            ])
+          end
+
+          it 'is aliased as #each_pair' do
+            headers['key1'] = 'value1'
+            headers['key2'] = 'value2'
+            yielded = []
+            headers.each_pair do |key, value|
+              yielded << [key, value]
+            end
+            expect(yielded.sort_by(&:first)).to eq([
+              ['key1', 'value1'],
+              ['key2', 'value2'],
+            ])
+          end
+
+        end
+
+        describe '#delete' do
+
+          it 'deletes a header by key' do
+            headers['key1'] = 'value1'
+            headers.delete('key1')
+            expect(headers).to_not have_key('key1')
+          end
+
+          it 'deletes header with a symbol key' do
+            headers['key1'] = 'value'
+            headers.delete(:key1)
+            expect(headers).to_not have_key('key1')
+            expect(headers).to_not have_key(:key1)
+          end
+
+          it 'deletes headers ignoring case' do
+            headers['key1'] = 'value'
+            headers['Key2'] = 'value'
+            headers.delete('Key1')
+            headers.delete('key2')
+            expect(headers).to_not have_key('key1')
+            expect(headers).to_not have_key('Key1')
+            expect(headers).to_not have_key('key2')
+            expect(headers).to_not have_key('Key2')
+          end
+
+        end
+
+        describe '#keys' do
+
+          it 'returns the keys' do
+            headers['key1'] = 'value1'
+            headers['key2'] = 'value2'
+            expect(headers.keys).to eql(['key1', 'key2'])
+          end
+
+        end
+
+        describe '#values' do
+
+          it 'returns the values' do
+            headers['key1'] = 'value1'
+            headers['key2'] = 'value2'
+            expect(headers.values).to eql(['value1', 'value2'])
+          end
+
+        end
+
+        describe '#values_at' do
+
+          it 'returns the values for the given keys' do
+            headers['key1'] = 'v1'
+            headers['key2'] = 'v2'
+            expect(headers.values_at('key2', 'key1')).to eql(['v2', 'v1'])
+          end
+
+        end
+
+        describe '#key?' do
+
+          it 'returns true if the header has been set' do
+            headers['foo'] = 'bar'
+            expect(headers.key?('foo')).to eq(true)
+          end
+
+          it 'treats symbols indifferently' do
+            headers['foo'] = 'bar'
+            expect(headers.key?(:foo)).to be(true)
+          end
+
+          it 'treats strings case insensitively' do
+            headers['foo'] = 'bar'
+            expect(headers.key?('Foo')).to be(true)
+          end
+
+          it 'returns false if the header has not been set' do
+            expect(headers.key?('foo')).to be(false)
+          end
+
+          it 'is aliased as #has_key?' do
+            headers['foo'] = 'bar'
+            expect(headers.has_key?('foo')).to be(true)
+          end
+
+          it 'is aliased as #include?' do
+            headers['foo'] = 'bar'
+            expect(headers.include?('foo')).to be(true)
+          end
+
+        end
+
+        describe '#inspect' do
+
+          it 'inspects like a normal hash' do
+            headers['foo'] = 'bar'
+            expect(headers.inspect).to eq({'foo' => 'bar'}.inspect)
+          end
+
+        end
+      end
+    end
+  end
+end

data/vendor/seahorse/spec/seahorse/client/http/plain_string_io_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module Seahorse
+  module Client
+    module Http
+      describe PlainStringIO do
+        it 'is a StringIO object' do
+          expect(PlainStringIO.new).to be_a(StringIO)
+        end
+
+        describe '#inspect' do
+          it 'inspects as the string data object' do
+            io = PlainStringIO.new
+            io.write("first\n")
+            io.write("last")
+            expect(io.read).to eq ''
+            expect(io.inspect).to eq '"first\nlast"'
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/seahorse/spec/seahorse/client/http/request_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+require 'stringio'
+
+module Seahorse
+  module Client
+    module Http
+      describe Request do
+
+        def request(*args) Request.new(*args) end
+
+        describe '#endpoint' do
+
+          it 'defaults to nil' do
+            expect(request.endpoint).to eq(nil)
+          end
+
+          it 'can be set in the constructor' do
+            endpoint = 'http://foo.com'
+            req = request(endpoint: endpoint)
+            expect(req.endpoint).to eq(endpoint)
+          end
+
+        end
+
+        describe '#http_method' do
+
+          it 'defaults to GET' do
+            expect(request.http_method).to eq('GET')
+          end
+
+          it 'can be set in the constructor' do
+            req = request(http_method: 'POST')
+            expect(req.http_method).to eq('POST')
+          end
+
+        end
+
+        describe '#path' do
+
+          it 'defaults to GET' do
+            expect(request.path).to eq('/')
+          end
+
+          it 'can be set in the constructor' do
+            req = request(path: '/path?abc=xyz')
+            expect(req.path).to eq('/path?abc=xyz')
+          end
+
+        end
+
+        describe '#pathname' do
+
+          it 'returns the path up to but not including the querystring' do
+            req = request(path: '/path?query')
+            expect(req.pathname).to eq('/path')
+          end
+
+          it 'returns the full path when a querystring is not present' do
+            req = request(path: '/path')
+            expect(req.pathname).to eq('/path')
+          end
+
+        end
+
+        describe '#querystring' do
+
+          it 'returns the querystring portion of the path' do
+            req = request(path: '/path?query')
+            expect(req.querystring).to eq('query')
+          end
+
+          it 'returns the empty string when not present' do
+            req = request(path: '/path')
+            expect(req.querystring).to eq('')
+          end
+
+        end
+
+        describe '#headers' do
+
+          it 'defaults to a Http::Headers' do
+            expect(request.headers).to be_kind_of(Headers)
+          end
+
+          it 'provides a default user agent' do
+            expect(request.headers.to_h).to eq(
+              'user-agent' => "Seahorse/#{Seahorse::VERSION}"
+            )
+          end
+
+          it 'sets a default user agent' do
+            ua = request.headers['User-Agent']
+            expect(ua).to eq("Seahorse/#{Seahorse::VERSION}")
+          end
+
+          it 'does not set the user-agent when given in the constructor' do
+            req = request(headers: { 'User-Agent' => 'ua' })
+            expect(req.headers['User-Agent']).to eq('ua')
+          end
+
+          it 'casts incoming headers as a Http::Headers object' do
+            req = request(headers: { 'User-Agent' => 'ua' })
+            expect(req.headers).to be_kind_of(Http::Headers)
+          end
+
+        end
+
+        describe '#body' do
+
+          it 'defaults to an empty IO-like object' do
+            expect(request.body.read).to eq('')
+          end
+
+          it 'can be set in the constructor' do
+            body = StringIO.new('body')
+            expect(request(body: body).body).to be(body)
+          end
+
+          it 'can be set as a string in the constructor' do
+            req = request(body: 'body')
+            expect(req.body).to be_a(PlainStringIO)
+            expect(req.body.read).to eq('body')
+          end
+
+          it 'converts nil bodies into empty io objects' do
+            req = request
+            req.body = nil
+            expect(req.body.read).to eq('')
+          end
+
+          it 'can be set as a string in accessor' do
+            req = request
+            req.body = 'body'
+            expect(req.body).to be_a(PlainStringIO)
+            expect(req.body.read).to eq('body')
+          end
+
+        end
+      end
+    end
+  end
+end

data/vendor/seahorse/spec/seahorse/client/http/response_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+module Seahorse
+  module Client
+    module Http
+      describe Response do
+
+        describe '#status_code' do
+
+          it 'defaults to 0' do
+            expect(Response.new.status_code).to eq(0)
+          end
+
+          it 'can be set' do
+            resp = Response.new
+            resp.status_code = 500
+            expect(resp.status_code).to eq(500)
+          end
+
+        end
+
+        describe '#headers' do
+
+          it 'is a Http::Headers' do
+            expect(Response.new.headers).to be_kind_of(Headers)
+          end
+
+          it 'defaults to a empty hash' do
+            expect(Response.new.headers.to_h).to eq({})
+          end
+
+          it 'can be set' do
+            headers = Headers.new
+            response = Response.new
+            response.headers = headers
+            expect(response.headers).to be(headers)
+          end
+
+        end
+
+        describe '#body' do
+
+          it 'defaults to an IO object' do
+            expect(Response.new.body).to respond_to(:write)
+            expect(Response.new.body).to respond_to(:read)
+            expect(Response.new.body).to respond_to(:rewind)
+          end
+
+          it 'defaults to an empty body' do
+            body = Response.new.body
+            body.rewind
+            expect(body.read).to eq('')
+          end
+
+          it 'can be set' do
+            body = Object.new
+            response = Response.new
+            response.body = body
+            expect(response.body).to be(body)
+          end
+
+        end
+
+        describe '#body_contents' do
+
+          it 'returns the body as a string' do
+            response = Response.new
+            response.body = StringIO.new('abc')
+            expect(response.body_contents).to eq(response.body.read)
+          end
+
+        end
+
+      end
+    end
+  end
+end