aws-sdk-core 2.0.0.rc1

data/spec/aws/query/param_list_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+module Aws
+  module Query
+    describe ParamList do
+
+      let(:list) { ParamList.new }
+
+      describe '#set' do
+
+        it 'returns a param' do
+          expect(list.set('name', 'value')).to be_kind_of(Param)
+        end
+
+        it 'sets a param with name and value' do
+          param = list.set('name', 'value')
+          expect(param.name).to eq('name')
+          expect(param.value).to eq('value')
+        end
+
+        it 'can set a param without a value' do
+          param = list.set('name')
+          expect(param.name).to eq('name')
+          expect(param.value).to be(nil)
+        end
+
+      end
+
+      describe '#delete' do
+
+        it 'removes a returns a param' do
+          param = list.set('name', 'value')
+          expect(list.delete('name')).to be(param)
+        end
+
+        it 'returns nil if the param was not seted' do
+          expect(list.delete('name')).to be(nil)
+        end
+
+      end
+
+      describe '#to_a' do
+
+        it 'returns an array of sorted Param objects' do
+          p1 = list.set('name2')
+          p2 = list.set('name1', 'value')
+          expect(list.to_a).to eq([p2, p1])
+        end
+
+      end
+
+      describe '#to_s' do
+
+        it 'returns the params as a string' do
+          list.set('name', 'value')
+          expect(list.to_s).to eq('name=value')
+        end
+
+        it 'joins multiple params with an ampersand' do
+          list.set('name1', 'value')
+          list.set('name2', 'value')
+          expect(list.to_s).to eq('name1=value&name2=value')
+        end
+
+        it 'sorts params' do
+          list.set('name2', 'value')
+          list.set('name1', 'value')
+          expect(list.to_s).to eq('name1=value&name2=value')
+        end
+
+        it 'escapes names and values' do
+          list.set('param name', 'val=u!')
+          expect(list.to_s).to eq('param%20name=val%3Du%21')
+        end
+
+      end
+
+    end
+  end
+end

data/spec/aws/query/param_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+module Aws
+  module Query
+    describe Param do
+
+      describe '#name' do
+
+        it 'returns the name' do
+          expect(Param.new('name').name).to eq('name')
+        end
+
+      end
+
+      describe '#value' do
+
+        it 'returns the value' do
+          expect(Param.new('name', 'value').value).to eq('value')
+        end
+
+        it 'defaults to nil' do
+          expect(Param.new('name').value).to be(nil)
+        end
+
+      end
+
+      describe '#to_s' do
+
+        it 'url encodes the name and value' do
+          param = Param.new('param name', 'val=u!')
+          expect(param.to_s).to eq('param%20name=val%3Du%21')
+        end
+
+      end
+
+      describe '#==' do
+
+        it 'returns true if two params are the same' do
+          expect(Param.new('name')).to eq(Param.new('name'))
+        end
+
+        it 'returns false if two params are different' do
+          expect(Param.new('name1')).not_to eq(Param.new('name2'))
+        end
+
+      end
+
+      describe '#<=>' do
+
+        it 'sorts params' do
+          p1 = Param.new('name1')
+          p2 = Param.new('name2')
+          expect([p2, p1].sort).to eq([p1, p2])
+        end
+
+      end
+    end
+  end
+end

data/spec/aws/service_spec.rb

@@ -0,0 +1,247 @@
+require 'spec_helper'
+
+module Aws
+  describe Service do
+
+    let(:api_older) {
+      api = Seahorse::Model::Api.new
+      api.version = '2013-01-01'
+      api
+    }
+
+    let(:api_newer) {
+      api = Seahorse::Model::Api.new
+      api.version = '2013-02-02'
+      api
+    }
+
+    let(:apis) { [api_newer, api_older] }
+
+    describe 'default_client_class' do
+
+      it 'returns a client with the default api version' do
+        svc = Service.define(:name, apis)
+        allow(svc).to receive(:default_api_version).and_return(api_older.version)
+        expect(svc.default_client_class.api).to be(api_older)
+      end
+
+    end
+
+    describe 'add_version' do
+
+      it 'registers a new API version' do
+        svc = Class.new(Service)
+        svc.add_version('2013-01-02', 'path/to/api.json')
+        expect(svc.api_versions).to eq(['2013-01-02'])
+      end
+
+      it 'can be called multiple times' do
+        svc = Class.new(Service)
+        svc.add_version('2013-02-03', 'path/to/api2.json')
+        svc.add_version('2013-01-02', 'path/to/api1.json')
+        expect(svc.api_versions).to eq(['2013-01-02', '2013-02-03'])
+        expect(svc.latest_api_version).to eq('2013-02-03')
+      end
+
+      it 'treats the newest api version as the default' do
+        svc = Class.new(Service)
+        svc.add_version('2013-02-03', 'path/to/api2.json')
+        svc.add_version('2013-01-02', 'path/to/api1.json')
+        expect(svc.default_api_version).to eq(svc.latest_api_version)
+      end
+
+    end
+
+    describe '.add_plugin' do
+
+      it 'adds a plugin to each versioned client class' do
+        plugin = double('plugin')
+        svc = Service.define(:name, apis)
+        svc.add_plugin(plugin)
+        svc.versioned_clients.each do |klass|
+          expect(klass.plugins).to include(plugin)
+        end
+      end
+
+    end
+
+    describe '.remove_plugin' do
+
+      it 'removes a plugin from each versioned client class' do
+        plugin = double('plugin')
+        svc = Service.define(:name, apis)
+        svc.add_plugin(plugin)
+        svc.remove_plugin(plugin)
+        svc.versioned_clients.each do |klass|
+          expect(klass.plugins).not_to include(plugin)
+        end
+      end
+
+    end
+
+    describe '.define' do
+
+      let(:apis) { [] }
+
+      let(:svc) {
+        svc = Service.define(:svc, apis)
+        svc.remove_plugin(Plugins::GlobalConfiguration)
+        svc.remove_plugin(Plugins::RegionalEndpoint)
+        svc
+      }
+
+      it 'defines a new client factory' do
+        expect(svc.ancestors).to include(Service)
+      end
+
+      it 'populates the method name' do
+        expect(svc.identifier).to eq(:svc)
+      end
+
+      it 'accepts apis as a path to a translated api' do
+        apis << 'apis/S3-2006-03-01.json'
+        client_class = svc.const_get(:V20060301)
+        allow(client_class).to receive(:svc).and_return('Aws::Svc::V20060301')
+        client = client_class.new(credentials: dummy_credentials)
+        expect(client.config.api.version).to eq('2006-03-01')
+      end
+
+      it 'accepts apis as a path to an un-translated api' do
+        apis << 'apis/source/s3-2006-03-01.json'
+        client_class = svc.const_get(:V20060301)
+        allow(client_class).to receive(:svc).and_return('Aws::Svc::V20060301')
+        client = client_class.new(credentials: dummy_credentials)
+        expect(client.config.api.version).to eq('2006-03-01')
+      end
+
+      it 'accepts apis as Seahorse::Model::Api' do
+        api = Seahorse::Model::Api.new
+        api.version = '2013-01-02'
+        svc = Service.define(:svc, [api])
+        expect(svc.const_get(:V20130102).new.config.api).to be(api)
+      end
+
+    end
+
+    describe 'new' do
+
+      after(:each) do
+        Aws.config = {}
+      end
+
+      it 'builds the client class with the latest api version by default' do
+        svc = Service.define(:name, apis)
+        expect(svc.new.config.api).to be(api_newer)
+        expect(svc.new).to be_kind_of(svc.const_get(:V20130202))
+      end
+
+      it 'defaults to the global configured version for the client' do
+        Aws.config[:client_name] = { api_version: api_older.version }
+        svc = Service.define(:client_name, apis)
+        expect(svc.new.config.api).to be(api_older)
+        expect(svc.new).to be_kind_of(svc.const_get(:V20130101))
+      end
+
+      it 'accepts the api verison as a constructor option' do
+        Aws.config[:client_name] = { api_version: api_older.version }
+        svc = Service.define(:client_name, apis)
+        client = svc.new(api_version: api_newer.version)
+        expect(client.config.api).to be(api_newer)
+        expect(client).to be_kind_of(svc.const_get(:V20130202))
+      end
+
+      it 'uses the closest version without going over' do
+        Aws.config[:api_version] = '2013-01-15'
+        svc = Service.define(:client_name, apis)
+        expect(svc.new.class).to be(svc.const_get(:V20130101))
+      end
+
+      it 'raises an error if the global version is preceedes all versions' do
+        Aws.config[:api_version] = '2000-00-00'
+        svc = Service.define(:client_name, apis)
+        expect {
+          expect(svc.new)
+        }.to raise_error(Errors::NoSuchApiVersionError, /2000-00-00/)
+      end
+
+      it 'merges global defaults options when constructing the client' do
+        # shared default
+        Aws.config = { region: 'us-east-1', credentials: dummy_credentials }
+        expect(Aws::EC2.new.config.region).to eq('us-east-1')
+        expect(Aws::S3.new.config.region).to eq('us-east-1')
+        # default enabled, s3 disables
+        Aws.config = {
+          credentials: dummy_credentials,
+          region: 'us-east-1', 
+          s3: { region: 'us-west-2' } 
+        }
+        expect(Aws::EC2.new.config.region).to eq('us-east-1')
+        expect(Aws::S3.new.config.region).to eq('us-west-2')
+      end
+
+    end
+
+    describe 'client classes' do
+
+      it 'returns each client class from .versioned_clients' do
+        svc = Service.define(:name, apis)
+        expect(svc.versioned_clients).to eq([
+          svc.const_get(:V20130101),
+          svc.const_get(:V20130202),
+        ])
+      end
+
+      it 'defines clients for each api version' do
+        target = Seahorse::Client::Base
+        c = Service.define(:name, apis)
+        expect(c.const_get(:V20130101).ancestors).to include(target)
+      end
+
+      it 'raises an error if the asked for client class does not exist' do
+        svc = Service.define(:name)
+        expect {
+          svc.const_get(:V20001012)
+        }.to raise_error(Errors::NoSuchApiVersionError)
+      end
+
+      it 'raises a helpful error when the api is not defined' do
+        svc = Service.define(:name)
+        expect {
+          svc.const_get(:V20001012)
+        }.to raise_error("API 2000-10-12 not defined for #{svc.name}")
+      end
+
+      it 'does not interfere with const missing' do
+        svc = Service.define(:name)
+        expect {
+          svc.const_get(:FooBar)
+        }.to raise_error(NameError, /uninitialized constant/)
+      end
+
+    end
+
+    describe 'Errors module' do
+
+      let(:svc) { Service.define(:name) }
+
+      let(:errors) { svc.const_get(:Errors) }
+
+      it 'has an errors module' do
+        expect(svc.const_defined?(:Errors)).to be(true)
+      end
+
+      it 'lazily creates error classes' do
+        err_class = errors.const_get(:AbcXyz)
+        expect(err_class.new).to be_kind_of(Errors::ServiceError)
+      end
+
+      it 'allows you to create error classes named like Ruby classes' do
+        error_class = Aws::Errors.error_class('S3', 'Range')
+        expect(error_class).not_to be(Range)
+        expect(error_class).to be(Aws::S3::Errors::Range)
+        expect(error_class.ancestors).to include(Errors::ServiceError)
+      end
+
+    end
+  end
+end

data/spec/aws/signers/v4_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+module Aws
+  module Signers
+    describe V4 do
+
+      let(:credentials) { Credentials.new('akid', 'secret') }
+      let(:datetime) { '20120101T10:11:12Z' }
+      let(:service_name) { 'SERVICE' }
+      let(:region) { 'REGION' }
+      let(:endpoint) { URI.parse('https://domain.com') }
+      let(:signer) { V4.new(credentials, service_name, region) }
+      let(:sign) { signer.sign(http_request) }
+      let(:http_request) do
+        req = Seahorse::Client::Http::Request.new(endpoint: endpoint)
+        req.headers.delete('User-Agent')
+        req
+      end
+
+      let(:now) { double('now') }
+      let(:utc) { double('utc-time') }
+      let(:datetime) { 'datetime' }
+
+      before(:each) {
+        allow(Time).to receive(:now).and_return(now)
+        allow(now).to receive(:utc).and_return(utc)
+        allow(utc).to receive(:strftime).and_return(datetime)
+      }
+
+      context '#sign' do
+
+        it "populates the 'HOST' header" do
+          expect(sign.headers['Host']).to eq('domain.com')
+        end
+
+        it "populates the 'X-Amz-Date' header" do
+          datetime = '20120102:10:11:12Z'
+          expect(utc).to receive(:strftime).with("%Y%m%dT%H%M%SZ") { datetime }
+          expect(sign.headers['X-Amz-Date']).to eq(datetime)
+        end
+
+        it 'sets the X-Amz-Date header' do
+          expect(sign.headers['X-Amz-Date']).to eq(datetime)
+        end
+
+        it "omits 'X-Amz-Security-Token' header when session token is nil" do
+          allow(credentials).to receive(:session_token).and_return(nil)
+          expect(sign.headers['X-Amz-Security-Token']).to be(nil)
+        end
+
+        it "populates the 'X-Amz-Security-Token' header with session token" do
+          allow(credentials).to receive(:session_token).and_return('session')
+          expect(sign.headers['X-Amz-Security-Token']).to eq('session')
+        end
+
+        it "populates the 'X-Amz-Content-Sha256' with the payload hexdigest" do
+          http_request.body = 'abc'
+          expect(sign.headers['X-Amz-Content-Sha256']).to eq(
+            Digest::SHA256.hexdigest('abc'))
+        end
+
+        it 'reads the http request payload in 1mb chunks' do
+          body = double('http-payload')
+          allow(body).to receive(:rewind)
+          expect(body).to receive(:read).with(1024 * 1024) { 'a' }
+          expect(body).to receive(:read).with(1024 * 1024) { 'b' }
+          expect(body).to receive(:read).with(1024 * 1024) { 'c' }
+          expect(body).to receive(:read).with(1024 * 1024) { nil }
+          http_request.body = body
+          expect(sign.headers['X-Amz-Content-Sha256']).to eq(
+            Digest::SHA256.hexdigest('abc'))
+        end
+
+        it 'does not re-compute the the content sha-256 when present' do
+          body = double('http-payload')
+          expect(body).to_not receive(:read)
+          expect(body).to_not receive(:rewind)
+          http_request.body = body
+          http_request.headers['X-Amz-Content-Sha256'] = 'hexdigest'
+          expect(sign.headers['X-Amz-Content-Sha256']).to eq('hexdigest')
+        end
+
+        it "populates the 'Authorization' header" do
+          expect(sign.headers['Authorization']).to_not be(nil)
+        end
+
+        it 'signs the request' do
+          datetime.replace('20120102T10:11:12Z')
+          http_request.headers['Foo'] = 'foo'
+          http_request.headers['Bar'] = 'bar  bar'
+          http_request.headers['Bar2'] = '"bar  bar"'
+          http_request.body = StringIO.new('http-body')
+          http_request.headers['Content-Length'] = 9
+          expect(sign.headers['Authorization']).to eq('AWS4-HMAC-SHA256 Credential=akid/20120102/REGION/SERVICE/aws4_request, SignedHeaders=bar;bar2;content-length;foo;host;x-amz-content-sha256;x-amz-date, Signature=6b40912702f78866fcd13804e2bc2703bf5f73264ebe0fa54a28d16bcdddb88c')
+        end
+
+      end
+
+      context '#signed_headers' do
+
+        it 'lower-cases and sort all header keys except authorization' do
+          http_request.headers['Xyz'] = '1'
+          http_request.headers['Abc'] = '2'
+          http_request.headers['Mno'] = '3'
+          http_request.headers['Authorization'] = '4'
+          http_request.headers['authorization'] = '5'
+          expect(signer.signed_headers(http_request)).to eq('abc;mno;xyz')
+        end
+
+      end
+
+      context '#canonical_headers' do
+
+        it 'lower-cases and sorts header by key except authorization' do
+          http_request.headers['Xyz'] = '1'
+          http_request.headers['Abc'] = '2'
+          http_request.headers['Mno'] = '3'
+          http_request.headers['Authorization'] = '4'
+          http_request.headers['authorization'] = '5'
+          expect(signer.canonical_headers(http_request)).to eq(<<-EOS.strip)
+abc:2
+mno:3
+xyz:1
+          EOS
+        end
+
+        it 'prunes expanded whitespace in header values' do
+          http_request.headers['Abc'] = 'a  b  c'
+          expect(signer.canonical_headers(http_request)).to eq("abc:a b c")
+        end
+
+        it 'leaves whitespace in quoted values in-tact' do
+          http_request.headers['Abc'] = '"a  b  c"'
+          expect(signer.canonical_headers(http_request)).to eq('abc:"a  b  c"')
+        end
+
+      end
+
+    end
+  end
+end