aws-sdk-core 2.0.0.rc1

data/spec/aws/json/parser_spec.rb

@@ -0,0 +1,238 @@
+require 'spec_helper'
+
+module Aws
+  module Json
+    describe Parser do
+
+      let(:rules) {{
+        'type' => 'input',
+        'members' => {},
+      }}
+
+      let(:shape) { Seahorse::Model::Shapes::Shape.from_hash(rules) }
+
+      def parse(json)
+        Parser.new.parse(shape, json).to_hash
+      end
+
+      it 'returns an empty hash when given an empty string' do
+        expect(parse('')).to eq({})
+      end
+
+      it 'returns an empty hash when the JSON is {}' do
+        expect(parse('{}')).to eq({})
+      end
+
+      describe 'structures' do
+
+        it 'symbolizes structure members' do
+          rules['members'] = {
+            'name' => { 'type' => 'string' },
+          }
+          json = '{"name":"John Doe"}'
+          expect(parse(json)).to eq(name: 'John Doe')
+        end
+
+        it 'parses members using their serialized name' do
+          rules['members'] = {
+            'first' => { 'type' => 'string', 'serialized_name' => 'FirstName' },
+            'last' => { 'type' => 'string', 'serialized_name' => 'LastName' }
+          }
+          json = '{"FirstName":"John", "LastName":"Doe"}'
+          expect(parse(json)).to eq(first: 'John', last: 'Doe')
+        end
+
+        it 'ignores non-described values' do
+          rules['members'] = {
+            'foo' => { 'type' => 'string' },
+          }
+          json = '{"foo":"bar", "abc":"xyz"}'
+          expect(parse(json)).to eq(foo: 'bar')
+        end
+
+        it 'skips over null values' do
+          rules['members'] = {
+            'base' => {
+              'type' => 'structure',
+              'members' => {
+                'nested' => {
+                  'type' => 'structure',
+                  'members' => {
+                    'leaf' => { 'type' => 'string' }
+                  }
+                }
+              }
+            },
+          }
+          json = '{"base":{"nested":null}}'
+          expect(parse(json)).to eq(base: {})
+        end
+
+      end
+
+      describe 'lists' do
+
+        it 'returns nil for lists missing in the json' do
+          rules['members'] = {
+            'items' => {
+              'type' => 'list',
+              'members' => { 'type' => 'string' }
+            }
+          }
+          json = '{}'
+          expect(parse(json)[:items]).to be(nil)
+        end
+
+        it 'parses lists' do
+          rules['members'] = {
+            'items' => {
+              'type' => 'list',
+              'members' => { 'type' => 'string' }
+            }
+          }
+          json = '{"items":["abc", "mno", "xyz"]}'
+          expect(parse(json)).to eq(items: %w(abc mno xyz))
+        end
+
+        it 'parses lists of complex members' do
+          rules['members'] = {
+            'items' => {
+              'type' => 'list',
+              'members' => {
+                'type' => 'structure',
+                'members' => {
+                  'name' => { 'type' => 'string' }
+                }
+              }
+            }
+          }
+          json = '{"items":[{"name":"abc"},{"name":"xyz"}]}'
+          expect(parse(json)).to eq(items: [{name:'abc'}, {name:'xyz'}])
+        end
+
+      end
+
+      describe 'maps' do
+
+        it 'parses maps as hashes (without symbolizing keys' do
+          rules['members'] = {
+            'attributes' => {
+              'type' => 'map',
+              'keys' => { 'type' => 'string' },
+              'members' => { 'type' => 'string' }
+            }
+          }
+          json = '{"attributes":{"Size":"large","Color":"red"}}'
+          expect(parse(json)).to eq(attributes: {
+            'Size' => 'large',
+            'Color' => 'red'
+          })
+        end
+
+      end
+
+      describe 'booleans' do
+
+        it 'converts true/false booleans' do
+          rules['members'] = {
+            'hot' => { 'type' => 'boolean' },
+            'cold' => { 'type' => 'boolean' },
+          }
+          json = '{"hot":true,"cold":false}'
+          expect(parse(json)).to eq(hot: true, cold: false)
+        end
+
+      end
+
+      describe 'timestamps' do
+
+        before(:each) do
+          rules['members'] = {
+            'created_at' => {
+              'type' => 'timestamp',
+              'serialized_name' => 'CreatedAt',
+            }
+          }
+        end
+
+        it 'can parse unix timestamps' do
+          timestamp = 1349908100
+          time = Time.at(timestamp)
+          json = "{\"CreatedAt\":#{timestamp}}"
+          data = parse(json)
+          expect(data[:created_at]).to be_a(Time)
+          expect(data[:created_at]).to eq(time)
+        end
+
+        it 'can parse unix timestamps expressed as floats' do
+          timestamp = 1349908100.123
+          time = Time.at(timestamp)
+          json = "{\"CreatedAt\":#{timestamp}}"
+          data = parse(json)
+          expect(data[:created_at]).to be_a(Time)
+          expect(data[:created_at]).to eq(time)
+        end
+
+        it 'can parse iso8601 strings' do
+          timestamp = '2012-09-10T15:47:10.001Z'
+          time = Time.parse(timestamp).to_time.utc
+          json = "{\"CreatedAt\":\"#{timestamp}\"}"
+          data = parse(json)
+          expect(data[:created_at]).to be_a(Time)
+          expect(data[:created_at]).to eq(time)
+        end
+
+        it 'can parse rfc822 strings' do
+          timestamp = 'Wed, 10 Oct 2012 15:59:55 UTC'
+          time = Time.parse(timestamp).to_time.utc
+          json = "{\"CreatedAt\":\"#{timestamp}\"}"
+          data = parse(json)
+          expect(data[:created_at]).to be_a(Time)
+          expect(data[:created_at]).to eq(time)
+        end
+
+      end
+
+      describe 'integers' do
+
+        it 'parses integers' do
+          rules['members'] = { 'count' => { 'type' => 'integer' } }
+          json = '{"count":123}'
+          expect(parse(json)).to eq(count: 123)
+        end
+
+      end
+
+      describe 'floats' do
+
+        it 'parses floats' do
+          rules['members'] = { 'value' => { 'type' => 'float' } }
+          json = '{"value":12.34}'
+          expect(parse(json)).to eq(value: 12.34)
+        end
+
+      end
+
+      describe 'blobs' do
+
+        it 'base64 decodes blobs' do
+          rules['members'] = {
+            'data' => { 'type' => 'blob' }
+          }
+          json = '{"data":"aGVsbG8="}'
+          expect(parse(json)).to eq(data: 'hello')
+        end
+
+      end
+
+      describe 'parsing errors' do
+
+        it 'does not trap xml parsing errors' do
+          json = '{"abc'
+          expect { parse(json) }.to raise_error
+        end
+
+      end
+    end
+  end
+end

data/spec/aws/operations_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+
+module Aws
+  describe 'Aws' do
+    class OperationFixture
+
+      Request = Struct.new(:method, :host, :headers, :path, :body)
+      Response = Struct.new(:status_code, :headers, :body)
+      Error = Struct.new(:class, :message)
+
+      def self.load(svc_name, fixture_name)
+        path = File.expand_path(File.join(File.dirname(__FILE__),
+          '..', 'fixtures', 'operations', svc_name, "#{fixture_name}.yml"))
+        self.new(YAML.load(File.read(path)))
+      end
+
+      def initialize(data)
+        @operation = data['operation']
+        @config = (data['config'] || {}).inject({}) do |config, (key, value)|
+          config.merge(key.to_sym => value)
+        end
+        @config[:region] ||= 'us-east-1'
+        @config[:credentials] = Credentials.new('akid', 'secret')
+        @params = data['params'] || {}
+        @data = data['data']
+
+        {
+          'error' => Error,
+          'request' => Request,
+          'response' => Response,
+        }.each do |entry, struct_class|
+          if data.key?(entry)
+            struct = struct_class.new
+            data[entry].each do |key, value|
+              struct[key] = value
+            end
+            instance_variable_set("@#{entry}", struct)
+          end
+        end
+
+        if @response
+          @response.status_code ||= 200
+          @response.headers = header_hash(@response.headers)
+          @response.body =
+            Seahorse::Client::Http::PlainStringIO.new(@response.body || '')
+        end
+      end
+
+      attr_reader :operation, :config, :params, :request, :response, :data, :error
+
+      def handler
+        FixtureHandler.new(self)
+      end
+
+      private
+
+      def header_hash(headers)
+        Seahorse::Client::Http::Headers.new(headers || {})
+      end
+
+    end
+
+    class FixtureHandler < Seahorse::Client::Handler
+
+      def initialize(fixture)
+        @f = fixture
+      end
+
+      attr_accessor :handler, :f
+
+      def call(context)
+        response = Seahorse::Client::Response.new(context: context)
+        if f.response
+          context.http_response.status_code = f.response.status_code
+          context.http_response.headers = f.response.headers
+          context.http_response.body = f.response.body
+        end
+        response
+      end
+
+    end
+
+    def request_assertions(f, http_req)
+      if f.request
+        expect(http_req.endpoint.host).to eq(f.request.host) if f.request.host
+        expect(http_req.http_method).to eq(f.request.method) if f.request.method
+        expect(http_req.path).to eq(f.request.path) if f.request.path
+        if f.request.headers
+          f.request.headers.each_pair do |header, value|
+            expected_value = value.nil? ? nil : value.to_s
+            expect(http_req.headers[header]).to eq(expected_value)
+          end
+        end
+        expect(http_req.body.read).to eq(f.request.body) if f.request.body
+      end
+    end
+
+    def response_assertions(f, resp)
+      if f.data
+        expect(resp.data.to_hash).to eq(f.data)
+      end
+
+      if f.error
+        expect(resp.data).to be(nil)
+        expect(resp.error.class.name).to eq(f.error.class) if f.error.class
+        expect(resp.error.message).to eq(f.error.message) if f.error.message
+      end
+    end
+
+    glob = File.expand_path(File.join(
+      File.dirname(__FILE__), '..', 'fixtures', 'operations', '**', '*.yml'))
+
+    Dir.glob(glob).group_by { |p| p.split('/')[-2] }.each do |svc_name, paths|
+      describe(svc_name) do
+        paths.each do |path|
+          fixture_name = path.split('/')[-1][0..-5]
+
+          it(fixture_name) do
+            # load the fixture from disk
+            f = OperationFixture.load(svc_name, fixture_name)
+
+            # remove the plugin that raises errors
+            Aws.service_classes[svc_name.to_sym].remove_plugin(
+              Seahorse::Client::Plugins::RaiseResponseErrors)
+
+            # build the service interface
+            svc = Aws.send(svc_name, f.config)
+
+            # build the request
+            req = svc.build_request(f.operation, f.params)
+            req.handler(f.handler, step: :send)
+
+
+            # send the request
+            resp = req.send_request
+
+            request_assertions(f, resp.http_request)
+            response_assertions(f, resp)
+
+          end
+        end
+      end
+    end
+  end
+end

data/spec/aws/plugins/credentials_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+module Aws
+  module Plugins
+    describe Credentials do
+
+      let(:env) {{}}
+
+      let(:plugin) { Plugins::Credentials.new }
+
+      before do
+        stub_const("ENV", env)
+      end
+
+      describe 'configuration' do
+
+        let(:config) { Seahorse::Client::Configuration.new }
+
+        it 'adds a credentials option' do
+          plugin.add_options(config)
+          expect(config.build!).to respond_to(:credentials)
+        end
+
+        it 'defaults to a Credentials object' do
+          plugin.add_options(config)
+          expect(config.build!.credentials).to be_kind_of(Aws::Credentials)
+        end
+
+        it 'hydrates credentials from the env (AWS_)' do
+          env['AWS_ACCESS_KEY_ID'] = 'akid'
+          env['AWS_SECRET_ACCESS_KEY'] = 'secret'
+          env['AWS_SESSION_TOKEN'] = 'token'
+          plugin.add_options(config)
+          cfg = config.build!
+          expect(cfg.credentials.set?).to be(true)
+          expect(cfg.credentials.access_key_id).to eq('akid')
+          expect(cfg.credentials.secret_access_key).to eq('secret')
+          expect(cfg.credentials.session_token).to eq('token')
+        end
+
+        it 'hydrates credentials from the env (AMAZON_)' do
+          env['AMAZON_ACCESS_KEY_ID'] = 'akid2'
+          env['AMAZON_SECRET_ACCESS_KEY'] = 'secret2'
+          env['AMAZON_SESSION_TOKEN'] = 'token2'
+          plugin.add_options(config)
+          cfg = config.build!
+          expect(cfg.credentials.set?).to be(true)
+          expect(cfg.credentials.access_key_id).to eq('akid2')
+          expect(cfg.credentials.secret_access_key).to eq('secret2')
+          expect(cfg.credentials.session_token).to eq('token2')
+        end
+
+        it 'hydrates credentials object from 3 options' do
+          options = {}
+          options[:access_key_id] = 'akid'
+          options[:secret_access_key] = 'secret'
+          options[:session_token] = 'session'
+          plugin.add_options(config)
+          cfg = config.build!(options)
+          expect(cfg.credentials.set?).to be(true)
+          expect(cfg.credentials.access_key_id).to eq('akid')
+          expect(cfg.credentials.secret_access_key).to eq('secret')
+          expect(cfg.credentials.session_token).to eq('session')
+        end
+
+        it 'raises an error if you construct a client without credentials' do
+          client_class = Seahorse::Client.define
+          client_class.add_plugin(Credentials)
+          expect { client_class.new }.to raise_error(Errors::MissingCredentialsError)
+        end
+
+      end
+
+    end
+  end
+end