aws-sdk-core 2.0.0.rc1

data/vendor/seahorse/spec/seahorse/client/xml/builder/xml_doc_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+require 'ostruct'
+
+module Seahorse
+  module Client
+    module Xml
+      class Builder
+        describe XmlDoc do
+
+          let(:result) { '' }
+
+          let(:options) { { target: result, indent: '' } }
+
+          let(:xml) { XmlDoc.new(options) }
+
+          it 'creates empty xml documents' do
+            xml.node('Xml')
+            expect(result).to eq('<Xml/>')
+          end
+
+          it 'nests elements' do
+            xml.node('xml') do
+              xml.node('element')
+            end
+            expect(result).to eq('<xml><element/></xml>')
+          end
+
+          it 'nests elements deeply' do
+            xml.node('xml') do
+              xml.node('a') do
+                xml.node('b') do
+                  xml.node('c')
+                end
+              end
+            end
+            expect(result).to eq('<xml><a><b><c/></b></a></xml>')
+          end
+
+          it 'supports flat elements with nested elements' do
+            xml.node('xml') do
+              xml.node('a') do
+                xml.node('b')
+              end
+              xml.node('c')
+            end
+            expect(result).to eq('<xml><a><b/></a><c/></xml>')
+          end
+
+          it 'accepts element values' do
+            xml.node('xml') do
+              xml.node('element', 'value')
+            end
+            expect(result).to eq('<xml><element>value</element></xml>')
+          end
+
+          it 'accepts element attributes' do
+            xml.node('xml') do
+              xml.node('el', abc: 123, mno: 'xyz')
+            end
+            expect(result).to eq('<xml><el abc="123" mno="xyz"/></xml>')
+          end
+
+          it 'accepts element values and attributes at the same time' do
+            xml.node('xml') do
+              xml.node('el', 'value', abc: 'xyz')
+            end
+            expect(result).to eq('<xml><el abc="xyz">value</el></xml>')
+          end
+
+          it 'accepts attributes on outer elements' do
+            xml.node('xml', xmlns: 'abc') do
+              xml.node('out', a: 'b') do
+                xml.node('c')
+              end
+            end
+            expect(result).to eq('<xml xmlns="abc"><out a="b"><c/></out></xml>')
+          end
+
+          #it 'escapes node values'
+
+          #it 'escapes attribute values'
+
+          it 'accepts :indent and initial :pad options' do
+            options[:indent] = '  '
+            options[:pad] = '  ' * 7
+            xml.node('xml', xmlns: 'http://example.com') do
+              xml.node('empty')
+              xml.node('attributes', a: 'b', c: 'd')
+              xml.node('value', 'content')
+              xml.node('both', 'content', m: 'n')
+              xml.node('branch') do
+                xml.node('leaf')
+                xml.node('branch') do
+                  xml.node('leaf', 'abc')
+                  xml.node('leaf', 'mno')
+                end
+                xml.node('branch') do
+                  xml.node('leaf', 'xyz')
+                end
+                xml.node('leaf')
+              end
+            end
+            expect(result).to eq(<<-XML)
+              <xml xmlns="http://example.com">
+                <empty/>
+                <attributes a="b" c="d"/>
+                <value>content</value>
+                <both m="n">content</both>
+                <branch>
+                  <leaf/>
+                  <branch>
+                    <leaf>abc</leaf>
+                    <leaf>mno</leaf>
+                  </branch>
+                  <branch>
+                    <leaf>xyz</leaf>
+                  </branch>
+                  <leaf/>
+                </branch>
+              </xml>
+            XML
+          end
+
+          it 'can build xml to any object that responds to #<<' do
+            options[:indent] = '  '
+            options[:pad] = '  ' * 7
+            options[:target] = []
+            xml.node('xml') do
+              xml.node('el', 'value')
+            end
+            expect(xml.target.join).to eq(<<-XML)
+              <xml>
+                <el>value</el>
+              </xml>
+            XML
+          end
+
+        end
+      end
+    end
+  end
+end

data/vendor/seahorse/spec/seahorse/client/xml/builder_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+module Seahorse
+  module Client
+    module Xml
+      describe Builder do
+      end
+    end
+  end
+end

data/vendor/seahorse/spec/seahorse/client_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+module Seahorse
+  describe Client do
+
+    it 'is a helper method for Client::Base.define' do
+      options = double('options')
+      expect(Client::Base).to receive(:define).with(options)
+      Client.define(options)
+    end
+
+  end
+end

data/vendor/seahorse/spec/seahorse/model/api_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+module Seahorse
+  module Model
+    describe Api do
+      let(:operation_hash) do
+        {
+          'name' => 'OperationName',
+          'http_method' => 'POST',
+          'http_path' => '/path/to/operation',
+          'input' => {
+            'type' => 'input',
+            'members' => {
+              'property' => { 'type' => 'string' }
+            }
+          }
+        }
+      end
+
+      let(:api_hash) do
+        {
+          'metadata' => {
+            'key' => 'value'
+          },
+          'documentation' => 'Docstring',
+          'operations' => {
+            'operation_name' => operation_hash
+          }
+        }
+      end
+
+      let(:api) { Api.from_hash(api_hash) }
+
+      describe 'from_hash' do
+        it 'loads from a hash' do
+          expect(api.metadata['key']).to eq 'value'
+          expect(api.documentation).to eq 'Docstring'
+          expect(api.operations[:operation_name].to_hash).to eq operation_hash
+          expect(api.operations['operation_name'].to_hash).to eq operation_hash
+        end
+
+        it 'underscore cases operation names' do
+          api = Api.from_hash 'operations' => { 'OperationName' => {} }
+          expect(api.operations[:operation_name]).to be_instance_of Operation
+        end
+      end
+
+      describe '#to_hash' do
+        it 'serializes to a hash' do
+          expect(api.to_hash).to eq(api_hash)
+        end
+      end
+
+      describe '#validate!' do
+        it 'returns true when an API is valid' do
+          expect(api.validate!).to be(true)
+        end
+
+        it 'fails to validate operations when an invalid operation is loaded' do
+          api = Api.from_hash 'operations' => {
+            'operation_name' => {
+              'INVALID_KEY' => 'value'
+            }
+          }
+
+          expect { api.validate! }.to raise_error(
+            RuntimeError, /Unrecognized properties/)
+        end
+      end
+    end
+  end
+end

data/vendor/seahorse/spec/seahorse/model/node_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+module Seahorse
+  module Model
+    describe Node do
+      describe 'property' do
+        it 'defines a property on the class' do
+          node = Class.new(Node) do
+            property :prop1, String
+            property :prop2, Integer, in: :subnode
+          end
+
+          expect(node.properties[:prop1].serialized_class).to eq(String)
+        end
+
+        it 'inherits properties from superclass' do
+          node1 = Class.new(Node) do
+            property :prop1, String
+          end
+
+          node2 = Class.new(node1) do
+            property :prop2, String
+          end
+
+          node3 = Class.new(node2)
+
+          expect(node1.properties.keys).to eq ['prop1']
+          expect(node2.properties.keys).to eq ['prop1', 'prop2']
+          expect(node3.properties.keys).to eq ['prop1', 'prop2']
+        end
+      end
+
+      describe 'from_hash' do
+        it 'loads node from hash' do
+          node_class = Class.new(Node) do
+            property :prop1, String
+            property :prop2, Symbol
+          end
+
+          node = node_class.from_hash('prop1' => 'a', 'prop2' => 'b')
+          expect(node.prop1).to eq 'a'
+          expect(node.prop2).to eq :b
+        end
+
+        it 'supports named properties' do
+          node_class = Class.new(Node) do
+            property :prop1, String, name: :a
+          end
+
+          node = node_class.from_hash('a' => 'a')
+          expect(node.prop1).to eq 'a'
+        end
+
+        it 'supports properties in sub-nodes' do
+          node_class = Class.new(Node) do
+            property :prop1, String, in: :subnode
+          end
+
+          node = node_class.from_hash('subnode' => {'prop1' => 'a'})
+          expect(node.prop1).to eq 'a'
+        end
+
+        it 'supports inherited properties in sub-nodes' do
+          node_class_super = Class.new(Node) do
+            property :prop1, String, in: :subnode
+          end
+          node_class = Class.new(node_class_super)
+
+          node = node_class.from_hash('subnode' => {'prop1' => 'a'})
+          expect(node.prop1).to eq 'a'
+        end
+
+        it 'supports shapes' do
+          node_class = Class.new(Node) do
+            property :shape, Shapes::StructureShape
+          end
+
+          node = node_class.from_hash 'shape' => {
+            'type' => 'structure',
+            'members' => {
+              'foo' => { 'type' => 'string' }
+            }
+          }
+
+          expect(node.shape).to be_instance_of Shapes::StructureShape
+          expect(node.shape.members[:foo]).to be_instance_of Shapes::StringShape
+        end
+
+        it 'fails if unrecognized keys are found' do
+          node_class = Class.new(Node)
+          hash = { 'node1' => 'a', 'node2' => 'b' }
+          expect { node_class.from_hash(hash) }.to raise_error(
+            RuntimeError, /Unrecognized properties: node1, node2/)
+        end
+      end
+
+      describe '#to_hash' do
+        it 'serializes all properties' do
+          node_class_super = Class.new(Node) do
+            property :prop1, String, in: :subnode
+          end
+          node_class = Class.new(node_class_super) do
+            property :prop2, Symbol
+          end
+
+          node = node_class.new
+          node.prop1 = 'a'
+          node.prop2 = :b
+          expect(node.to_hash).to eq('subnode' => {'prop1' => 'a'}, 'prop2' => 'b')
+        end
+      end
+    end
+  end
+end

data/vendor/seahorse/spec/seahorse/model/operation_input_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+module Seahorse
+  module Model
+    describe Operation do
+      let(:input_hash) do
+        {
+          'params' => {
+            'body1' => { 'type' => 'string' },
+            'body2' => { 'type' => 'string', 'location' => 'body' },
+            'body3' => { 'type' => 'string', 'location' => 'body' },
+            'uri1' => { 'type' => 'string', 'location' => 'uri' },
+            'uri2' => { 'type' => 'string', 'location' => 'uri' },
+            'header1' => { 'type' => 'string', 'location' => 'header' }
+          },
+          'raw_payload' => true
+        }
+      end
+
+      let(:input) { OperationInput.from_hash(input_hash) }
+
+      describe 'from_hash' do
+        it 'loads from a hash' do
+          params = input.params
+          expect(params.values.map(&:class).uniq).to eq [Shapes::StringShape]
+          expect(input.raw_payload).to eq true
+        end
+
+        it 'serializes to a hash' do
+          expect(input.to_hash).to eq(input_hash)
+        end
+      end
+
+      describe '#body_params' do
+        it 'loads all body parameters' do
+          expect(input.body_params.keys).to eq [:body1, :body2, :body3]
+        end
+      end
+
+      describe '#uri_params' do
+        it 'loads all URI parameters' do
+          expect(input.uri_params.keys).to eq [:uri1, :uri2]
+        end
+      end
+
+      describe '#header_params' do
+        it 'loads all header parameters' do
+          expect(input.header_params.keys).to eq [:header1]
+        end
+      end
+    end
+  end
+end

data/vendor/seahorse/spec/seahorse/model/operation_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+module Seahorse
+  module Model
+    describe Operation do
+      let(:operation_hash) do
+        {
+          'name' => 'OperationName',
+          'documentation' => 'Docstring',
+          'http_method' => 'POST',
+          'http_path' => '/path/to/operation',
+          'input' => {
+            'type' => 'input',
+            'members' => {
+              'property' => { 'type' => 'string' }
+            }
+          },
+          'errors' => [
+            {
+              'type' => 'string'
+            },
+            {
+              'type' => 'integer'
+            }
+          ]
+        }
+      end
+
+      let(:operation) { Operation.from_hash(operation_hash) }
+
+      describe 'from_hash' do
+        it 'loads from a hash' do
+          expect(operation.name).to eq 'OperationName'
+          expect(operation.documentation).to eq 'Docstring'
+          expect(operation.http_path).to eq '/path/to/operation'
+          expect(operation.http_method).to eq 'POST'
+          expect(operation.input).to be_instance_of Shapes::InputShape
+          expect(operation.output).to be_instance_of Shapes::OutputShape
+          expect(operation.errors[0]).to be_instance_of Shapes::StringShape
+        end
+
+        it 'serializes to a hash' do
+          expect(operation.to_hash).to eq(operation_hash)
+        end
+      end
+    end
+  end
+end