aws-sdk-core 2.0.0.rc1

data/vendor/seahorse/spec/seahorse/client/param_converter_spec.rb

@@ -0,0 +1,318 @@
+require 'stringio'
+
+module Seahorse
+  module Client
+    describe ParamConverter do
+
+      describe 'convert' do
+
+        it 'performs a deeply nested conversion of values' do
+          rules = Model::Shapes::Shape.from_hash({
+            'type' => 'input',
+            'members' => {
+              'username' => { 'type' => 'string' },
+              'config' => {
+                'type' => 'structure',
+                'members' => {
+                  'enabled' => { 'type' => 'boolean' },
+                  'settings' => {
+                    'type' => 'map',
+                    'keys' => { 'type' => 'string' },
+                    'members' => { 'type' => 'string' },
+                  },
+                  'counts' => {
+                    'type' => 'list',
+                    'members' => { 'type' => 'integer' },
+                  }
+                }
+              }
+            }
+          })
+
+          data = double('data')
+
+          config = Struct.new(:enabled, :settings, :counts, :unknown)
+          config = config.new(true, { color: :red }, [1, 2.0, '3'], data)
+
+          params = {
+            username: :johndoe,
+            config: config
+          }
+
+          converted = ParamConverter.convert(rules, params)
+          expect(converted).to eq({
+            username: 'johndoe',
+            config: {
+              enabled: true,
+              settings: { 'color' => 'red' },
+              counts: [1, 2, 3],
+              unknown: data
+            }
+          })
+        end
+
+      end
+
+      describe 'default converstions' do
+
+        describe 'undescribed' do
+
+          it 'returns the value unmodified if the shape class is unknown' do
+            shape_class = Class.new
+            value = 'raw'
+            expect(ParamConverter.c(shape_class, value)).to be(value)
+          end
+
+          it 'returns the value unmodified if the value class is unknown' do
+            shape_class = Model::Shapes::StringShape
+            value = double('raw')
+            expect(ParamConverter.c(shape_class, value)).to be(value)
+          end
+
+        end
+
+        describe 'structures' do
+
+          let(:shape_class) { Model::Shapes::StructureShape }
+
+          it 'returns duplicate hashes' do
+            value = { a: 1 }
+            converted = ParamConverter.c(shape_class, value)
+            expect(converted).to eq(value)
+            expect(converted).not_to be(value)
+          end
+
+          it 'creates a hash from a struct' do
+            value = Struct.new(:a).new(1)
+            converted = ParamConverter.c(shape_class, value)
+            expect(converted).to eq(a: 1)
+          end
+
+        end
+
+        describe 'maps' do
+
+          let(:shape_class) { Model::Shapes::MapShape }
+
+          it 'returns duplicate hashes' do
+            value = { a: 1 }
+            converted = ParamConverter.c(shape_class, value)
+            expect(converted).to eq(value)
+            expect(converted).not_to be(value)
+          end
+
+          it 'creates a hash from a struct' do
+            value = Struct.new(:a).new(1)
+            converted = ParamConverter.c(shape_class, value)
+            expect(converted).to eq(a: 1)
+          end
+
+        end
+
+        describe 'lists' do
+
+          let(:shape_class) { Model::Shapes::ListShape }
+
+          it 'duplicates arrays' do
+            value = [1,2,3]
+            converted = ParamConverter.c(shape_class, value)
+            expect(converted).to eq(value)
+            expect(converted).not_to be(value)
+          end
+
+          it 'converts enumerables into arrays' do
+            value = [1,2,3].enum_for(:each)
+            converted = ParamConverter.c(shape_class, value)
+            expect(converted).to eq([1,2,3])
+          end
+
+        end
+
+        describe 'strings' do
+
+          let(:shape_class) { Model::Shapes::StringShape }
+
+          it 'returns strings unmodified' do
+            expect(ParamConverter.c(shape_class, 'abc')).to eq('abc')
+          end
+
+          it 'converts symbols to strings' do
+            expect(ParamConverter.c(shape_class, :abc)).to eq('abc')
+          end
+
+        end
+
+        describe 'integers' do
+
+          let(:shape_class) { Model::Shapes::IntegerShape }
+
+          it 'returns integers unmodified' do
+            expect(ParamConverter.c(shape_class, 123)).to eq(123)
+          end
+
+          it 'converts floats to integers' do
+            expect(ParamConverter.c(shape_class, 12.34)).to eq(12)
+          end
+
+          it 'casts strings to integers' do
+            expect(ParamConverter.c(shape_class, '123')).to eq(123)
+          end
+
+          it 'returns strings unmodified if cast fails' do
+            expect(ParamConverter.c(shape_class, 'abc')).to eq('abc')
+          end
+
+        end
+
+        describe 'floats' do
+
+          let(:shape_class) { Model::Shapes::FloatShape }
+
+          it 'returns floats unmodified' do
+            expect(ParamConverter.c(shape_class, 12.34)).to eq(12.34)
+          end
+
+          it 'converts integers to floats' do
+            expect(ParamConverter.c(shape_class, 12)).to eq(12.0)
+          end
+
+          it 'casts strings to floats' do
+            expect(ParamConverter.c(shape_class, '12.34')).to eq(12.34)
+          end
+
+          it 'returns strings unmodified if cast fails' do
+            expect(ParamConverter.c(shape_class, 'abc')).to eq('abc')
+          end
+
+        end
+
+        describe 'timestamps' do
+
+          [
+            Model::Shapes::TimestampShape,
+            Model::Shapes::Iso8601TimestampShape,
+            Model::Shapes::Rfc822TimestampShape,
+            Model::Shapes::UnixTimestampShape,
+          ].each do |shape_class|
+
+            describe(shape_class.name.split('::').last) do
+
+              it 'returns Time objects unmodfied' do
+                time = Time.now
+                expect(ParamConverter.c(shape_class, time)).to be(time)
+              end
+
+              it 'returns DateTime objects as a Time object' do
+                time = DateTime.now
+                expect(ParamConverter.c(shape_class, time)).to eq(time.to_time)
+              end
+
+              it 'returns Date objects as a Time object' do
+                time = Date.new
+                expect(ParamConverter.c(shape_class, time)).to eq(time.to_time)
+              end
+
+              it 'converts integers to Time objects' do
+                time = Time.now.to_i
+                expect(ParamConverter.c(shape_class, time)).to eq(Time.at(time))
+              end
+
+              it 'parses strings as time objets' do
+                t1 = Time.now.utc.iso8601
+                t2 = Time.now.rfc822
+                t3 = Time.now.to_s
+                t4 = '2013-01-02'
+                expect(ParamConverter.c(shape_class, t1)).to eq(Time.parse(t1))
+                expect(ParamConverter.c(shape_class, t2)).to eq(Time.parse(t2))
+                expect(ParamConverter.c(shape_class, t3)).to eq(Time.parse(t3))
+                expect(ParamConverter.c(shape_class, t4)).to eq(Time.parse(t4))
+              end
+
+              it 'returns strings unmodified if they can not be parsed' do
+                expect(ParamConverter.c(shape_class, 'abc')).to eq('abc')
+              end
+
+            end
+
+          end
+
+        end
+
+        describe 'booleans' do
+
+          let(:shape_class) { Model::Shapes::BooleanShape }
+
+          it 'returns true and false' do
+            expect(ParamConverter.c(shape_class, true)).to be(true)
+            expect(ParamConverter.c(shape_class, false)).to be(false)
+          end
+
+          it 'does not translate nil' do
+            expect(ParamConverter.c(shape_class, nil)).to be(nil)
+          end
+
+        end
+
+        describe 'blobs' do
+
+          let(:shape_class) { Model::Shapes::BlobShape }
+
+          it 'accepts io objects (like file)' do
+            file = File.open(__FILE__, 'r')
+            expect(ParamConverter.c(shape_class, file)).to be(file)
+            file.close
+          end
+
+          it 'accepts io objects (like stringio)' do
+            io = StringIO.new('abc')
+            expect(ParamConverter.c(shape_class, io)).to be(io)
+          end
+
+          it 'accepts io objects (like tempfiles)' do
+            file = Tempfile.new('abc')
+            expect(ParamConverter.c(shape_class, file)).to be(file)
+            file.delete
+          end
+
+          it 'accepts and returns strings' do
+            expect(ParamConverter.c(shape_class, 'abc')).to eq('abc')
+          end
+
+        end
+
+      end
+
+      describe '.add' do
+
+        it 'registers a new converter' do
+          shape_class = Class.new
+          ParamConverter.add(shape_class, String) { |s| s.to_sym }
+          expect(ParamConverter.c(shape_class, 'abc')).to eq(:abc)
+        end
+
+        it 'can convert values based on parent value classes' do
+          shape_class = Class.new
+          special_string = Class.new(String)
+          str = special_string.new('raw')
+          ParamConverter.add(shape_class, special_string) { |s| 'converted' }
+          expect(ParamConverter.c(shape_class, str)).to eq('converted')
+        end
+
+        it 'can convert values based on parent shape classes' do
+          base = Class.new
+          extended = Class.new(base)
+          ParamConverter.add(base, String) { |s| 'converted' }
+          expect(ParamConverter.c(extended, 'raw')).to eq('converted')
+        end
+
+        it 'replaces an existing converter' do
+          shape_class = Class.new
+          ParamConverter.add(shape_class, String) { |s| 'first' }
+          ParamConverter.add(shape_class, String) { |s| 'second' }
+          expect(ParamConverter.c(shape_class, 'value')).to eq('second')
+        end
+
+      end
+    end
+  end
+end

data/vendor/seahorse/spec/seahorse/client/param_validator_spec.rb

@@ -0,0 +1,271 @@
+module Seahorse
+  module Client
+    describe ParamValidator do
+
+      let(:rules) {{ 'type' => 'input', 'members' => {} }}
+
+      def validate(params, expected_errors = [])
+        shape = Model::Shapes::Shape.from_hash(rules)
+        if expected_errors.empty?
+          ParamValidator.new(shape).validate!(params)
+        else
+          expect {
+            ParamValidator.new(shape).validate!(params)
+          }.to raise_error(ArgumentError) do |error|
+            match_errors(error, expected_errors)
+          end
+        end
+      end
+
+      def match_errors(error, expected_errors)
+        expected_errors = [expected_errors] unless expected_errors.is_a?(Array)
+        expected_errors.each do |expected_error|
+          if String === expected_error
+            expect(error.message).to include(expected_error)
+          else
+            expect(error.message).to match(expected_error)
+          end
+        end
+      end
+
+      describe 'empty rules' do
+
+        it 'accepts an empty hash of params when rules are empty' do
+          expect(validate({}))
+        end
+
+      end
+
+      describe 'structures' do
+
+        it 'validates nested structures' do
+          rules['members'] = {
+            'config' => {
+              'type' => 'structure',
+              'members' => {
+                'settings' => {
+                  'type' => 'structure',
+                  'members' => {}
+                }
+              }
+            }
+          }
+          validate('abc', 'expected params to be a hash')
+          validate({ config: 'abc' }, 'expected params[:config] to be a hash')
+          validate({ config: { settings: 'abc' }}, 'expected params[:config][:settings] to be a hash')
+        end
+
+        it 'accepts hashes' do
+          validate({})
+        end
+
+        it 'raises an error when a required paramter is missing' do
+          rules['members'] = {
+            'name' => { 'type' => 'string', 'required' => true }
+          }
+          validate({}, 'missing required parameter params[:name]')
+        end
+
+        it 'raises an error when a given parameter is unexpected' do
+          validate({foo: 'bar'}, 'unexpected value at params[:foo]')
+        end
+
+        it 'accepts members that pass validation' do
+          rules['members'] = {
+            'name' => { 'type' => 'string', 'required' => true }
+          }
+          validate(name: 'john doe')
+        end
+
+        it 'aggregates errors for members' do
+          rules['members'] = {
+            'name' => { 'type' => 'string', 'required' => true }
+          }
+          validate({foo: 'bar'}, [
+            'missing required parameter params[:name]',
+            'unexpected value at params[:foo]'
+          ])
+        end
+
+        it 'provides a helpful context for nested params' do
+          rules['members'] = {
+            'config' => {
+              'type' => 'structure',
+              'members' => {
+                'name' => { 'type' => 'string', 'required' => true }
+              }
+            }
+          }
+          validate({ config: {} },
+            'missing required parameter params[:config][:name]')
+        end
+
+      end
+
+      describe 'lists' do
+
+        before(:each) do
+          rules['members'] = {
+            # list of strings
+            'names' => {
+              'type' => 'list',
+              'members' => { 'type' => 'string' }
+            },
+            # list of structures
+            'filters' => {
+              'type' => 'list',
+              'members' => {
+                'type' => 'structure',
+                'members' => {
+                  'values' => {
+                    'type' => 'list',
+                    'members' => { 'type' => 'string' }
+                  }
+                }
+              }
+            }
+          }
+        end
+
+        it 'accepts arrays' do
+          validate(names: [])
+          validate(names: %w(abc mno xyz))
+        end
+
+        it 'expects the value to be an array' do
+          validate({ names: [] })
+          validate({ names: 'abc' }, 'expected params[:names] to be an array')
+        end
+
+        it 'validates each member of the list' do
+          validate({ filters: [{}] })
+          validate({ filters: ['abc'] },
+            'expected params[:filters][0] to be a hash')
+          validate({ filters: [{}, 'abc'] },
+            'expected params[:filters][1] to be a hash')
+          validate({ filters: [{ values: 'abc' }] },
+            'expected params[:filters][0][:values] to be an array')
+          validate({ filters: [{ value: 'abc' }] },
+            'unexpected value at params[:filters][0][:value]')
+        end
+
+      end
+
+      describe 'maps' do
+
+        before(:each) do
+          rules['members'] = {
+            'attributes' => {
+              'type' => 'map',
+              'keys' => { 'type' => 'string' },
+              'members' => { 'type' => 'integer' }
+            }
+          }
+        end
+
+        it 'accepts hashes' do
+          validate({ attributes: {}})
+          validate({ attributes: 'abc' },
+            'expected params[:attributes] to be a hash')
+        end
+
+        it 'validates map keys' do
+          validate({ attributes: { 'foo' => 123 }})
+          validate({ attributes: { 123 => 456 }},
+            'expected params[:attributes] 123 key to be a string')
+        end
+
+        it 'validates map values' do
+          validate({ attributes: { 'foo' => 123 }})
+          validate({ attributes: { 'foo' => 'bar' }},
+            'expected params[:attributes]["foo"] to be an integer')
+        end
+
+      end
+
+      describe 'integers' do
+
+        it 'accepts integers' do
+          rules['members'] = { 'count' => { 'type' => 'integer' } }
+          validate(count: 123)
+          validate({ count: '123' }, 'expected params[:count] to be an integer')
+        end
+
+      end
+
+      describe 'floats' do
+
+        it 'accepts integers' do
+          rules['members'] = { 'price' => { 'type' => 'float' } }
+          validate(price: 123.0)
+          validate({ price: 123 }, 'expected params[:price] to be a float')
+        end
+
+      end
+
+      describe 'timestamps' do
+
+        it 'accepts time objects' do
+          rules['members'] = {
+            'a' => { 'type' => 'timestamp' },
+            'b' => { 'type' => 'iso8601_timestamp' },
+            'c' => { 'type' => 'rfc822_timestamp' },
+            'd' => { 'type' => 'unix_timestamp' },
+          }
+          validate(a: Time.now)
+          validate(b: Time.now)
+          validate(c: Time.now)
+          validate(d: Time.now)
+          validate({a: 12345}, 'expected params[:a] to be a Time object')
+          validate({b: '2013-01-01'}, 'expected params[:b] to be a Time object')
+          validate({c: DateTime.now}, 'expected params[:c] to be a Time object')
+          validate({d: Date.new}, 'expected params[:d] to be a Time object')
+        end
+
+      end
+
+      describe 'booleans' do
+
+        it 'accepts TrueClass and FalseClass' do
+          rules['members'] = { 'enabled' => { 'type' => 'boolean' } }
+          validate(enabled: true)
+          validate(enabled: false)
+          validate({ enabled: 'true' },
+            'expected params[:enabled] to be true or false')
+        end
+
+      end
+
+      describe 'blobs' do
+
+        it 'accepts strings and io objects for payload members' do
+          rules['payload'] = 'data'
+          rules['members'] = {
+            'data' => { 'type' => 'blob' }
+          }
+          validate(data: StringIO.new('abc'))
+          validate(data: double('d', :read => 'abc', :size => 3, :rewind => 0))
+          validate({ data: 'abc' })
+        end
+
+        it 'accepts string objects for non-payload members' do
+          rules['members'] = { 'data' => { 'type' => 'blob' } }
+          validate(data: 'YQ==')
+          validate({ data: 123 },
+            'expected params[:data] to be a string or IO object')
+        end
+
+      end
+
+      describe 'strings' do
+
+        it 'accepts string objects' do
+          rules['members'] = { 'name' => { 'type' => 'string' } }
+          validate(name: 'john doe')
+          validate({ name: 123 }, 'expected params[:name] to be a string')
+        end
+
+      end
+    end
+  end
+end