mws-connect 0.0.1

data/spec/mws/apis/feeds/submission_info_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+require 'nokogiri'
+
+module Mws::Apis::Feeds
+
+  describe SubmissionInfo do 
+
+    let(:submitted_node) do
+      Nokogiri::XML::Builder.new do
+        FeedSubmissionInfo {
+          FeedSubmissionId 5868304010
+          FeedType '_POST_PRODUCT_DATA_'
+          SubmittedDate '2012-10-16T21:19:08+00:00'
+          FeedProcessingStatus '_SUBMITTED_'
+        }
+      end.doc.root
+    end
+
+    let(:in_progress_node) do
+      Nokogiri::XML::Builder.new do
+        FeedSubmissionInfo {
+          FeedSubmissionId 5868304010
+          FeedType '_POST_PRODUCT_DATA_'
+          SubmittedDate '2012-10-16T21:19:08+00:00'
+          FeedProcessingStatus '_IN_PROGRESS_'
+          StartedProcessingDate '2012-10-16T21:21:35+00:00'
+        }
+      end.doc.root
+    end
+
+    let(:done_node) do
+      Nokogiri::XML::Builder.new do
+        FeedSubmissionInfo {
+          FeedSubmissionId 5868304010
+          FeedType '_POST_PRODUCT_DATA_'
+          SubmittedDate '2012-10-16T21:19:08+00:00'
+          FeedProcessingStatus '_DONE_'
+          StartedProcessingDate '2012-10-16T21:21:35+00:00'
+          CompletedProcessingDate '2012-10-16T21:23:40+00:00'
+        }
+      end.doc.root
+    end
+
+    it 'should not allow instance creation via new' do
+      expect { SubmissionInfo.new }.to raise_error NoMethodError
+    end
+
+    context '.from_xml' do
+
+      it 'should be able to create an info object in a submitted state' do
+        info = SubmissionInfo.from_xml submitted_node
+        info.id.should == "5868304010"
+        info.status.should == SubmissionInfo::Status.SUBMITTED.sym
+        info.type.should == Feed::Type.PRODUCT.sym
+        info.submitted.should == Time.parse('2012-10-16T21:19:08+00:00')
+        info.started.should be_nil
+        info.completed.should be_nil
+      end
+
+      it 'should be able to create an info object in and in progress state' do
+        info = SubmissionInfo.from_xml in_progress_node
+        info.id.should == "5868304010"
+        info.status.should == SubmissionInfo::Status.IN_PROGRESS.sym
+        info.type.should == Feed::Type.PRODUCT.sym
+        info.submitted.should == Time.parse('2012-10-16T21:19:08+00:00')
+        info.started.should == Time.parse('2012-10-16T21:21:35+00:00')
+        info.completed.should be_nil
+      end
+
+      it 'should be able to create an info object in a done state' do
+        info = SubmissionInfo.from_xml done_node
+        info.id.should == "5868304010"
+        info.status.should == SubmissionInfo::Status.DONE.sym
+        info.type.should == Feed::Type.PRODUCT.sym
+        info.submitted.should == Time.parse('2012-10-16T21:19:08+00:00')
+        info.started.should == Time.parse('2012-10-16T21:21:35+00:00')
+        info.completed.should == Time.parse('2012-10-16T21:23:40+00:00')
+      end
+
+    end
+
+    context '#==' do
+
+      it 'should be reflexive' do
+        a = SubmissionInfo.from_xml submitted_node
+        (a == a).should be true
+      end
+
+      it 'should be symmetric' do
+        a = SubmissionInfo.from_xml submitted_node
+        b = SubmissionInfo.from_xml submitted_node
+        (a == b).should == (b == a)
+      end
+
+      it 'should be transitive' do
+        a = SubmissionInfo.from_xml submitted_node
+        b = SubmissionInfo.from_xml submitted_node
+        c = SubmissionInfo.from_xml submitted_node
+        (a == c).should == (a == b && b == c)
+      end
+
+      it 'should handle comparison to nil' do
+        a = SubmissionInfo.from_xml submitted_node
+        (a == nil).should be false
+      end
+
+    end
+
+  end
+
+end

data/spec/mws/apis/feeds/submission_result_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+require 'nokogiri'
+
+module Mws::Apis::Feeds
+
+  class SubmissionResult
+    attr_reader :responses
+  end
+
+  describe SubmissionResult do 
+    let(:success_node) do
+      Nokogiri::XML::Builder.new do
+        Message {
+          MessageID 1
+          ProcessingReport {
+            DocumentTransactionID 5868304010
+            StatusCode 'Complete'
+            ProcessingSummary {
+              MessagesProcessed 1
+              MessagesSuccessful 1
+              MessagesWithError 0
+              MessagesWithWarning 0
+            }
+          }
+        }
+      end.doc.root
+    end
+    let(:error_node) do
+      Nokogiri::XML::Builder.new do
+        Message {
+          MessageID 1
+          ProcessingReport {
+            DocumentTransactionID 5868304010
+            StatusCode 'Complete'
+            ProcessingSummary {
+              MessagesProcessed 2
+              MessagesSuccessful 0
+              MessagesWithError 2
+              MessagesWithWarning 1
+            }
+            Result {
+              MessageID 1
+              ResultCode 'Error'
+              ResultMessageCode 8560
+              ResultDescription 'Result description 1'
+              AdditionalInfo {
+                SKU '3455449'
+              }
+            }
+            Result {
+              MessageID 2
+              ResultCode 'Error'
+              ResultMessageCode 5000
+              ResultDescription "Result description 2"
+              AdditionalInfo {
+                SKU '8744969'
+              }
+            }
+            Result {
+              MessageID 3
+              ResultCode 'Warning'
+              ResultMessageCode 5001
+              ResultDescription "Result description 3"
+              AdditionalInfo {
+                SKU '7844970'
+              }
+            }
+          }
+        }
+      end.doc.root
+    end
+
+    it 'should not allow instance creation via new' do
+      expect { SubmissionResult.new }.to raise_error NoMethodError
+    end
+
+    describe '.from_xml' do
+
+      it 'should be able to be constructed from valid success xml' do
+        result = SubmissionResult.from_xml success_node
+        result.transaction_id.should == '5868304010'
+        result.status.should == SubmissionResult::Status.COMPLETE.sym
+        result.messages_processed.should == 1
+        result.count_for(:success).should == 1
+        result.count_for(:error).should == 0
+        result.count_for(:warning).should == 0
+        result.responses.should be_empty
+      end
+
+      it 'should be able to be constructed from valid error xml' do 
+        result = SubmissionResult.from_xml error_node
+        result.transaction_id.should == '5868304010'
+        result.status.should == SubmissionResult::Status.COMPLETE.sym
+        result.messages_processed.should == 2
+        result.count_for(:success).should == 0
+        result.count_for(:error).should == 2
+        result.count_for(:warning).should == 1
+        result.responses.size.should == 3
+
+        response = result.response_for 1
+        response.type.should == SubmissionResult::Response::Type.ERROR.sym
+        response.code.should == 8560
+        response.description == 'Result description 1'
+        response.additional_info.should == {
+          sku: '3455449'
+        }
+
+
+        response = result.response_for 2
+        response.type.should == SubmissionResult::Response::Type.ERROR.sym
+        response.code.should == 5000
+        response.description == 'Result description 2'
+        response.additional_info.should == {
+          sku: '8744969'
+        }
+
+        response = result.response_for 3
+        response.type.should == SubmissionResult::Response::Type.WARNING.sym
+        response.code.should == 5001
+        response.description == 'Result description 3'
+        response.additional_info.should == {
+          sku: '7844970'
+        }
+      end
+
+    end
+
+    context '#==' do
+
+      it 'should be reflexive' do
+        a = SubmissionResult.from_xml success_node
+        (a == a).should be true
+      end
+
+      it 'should be symmetric' do
+        a = SubmissionResult.from_xml success_node
+        b = SubmissionResult.from_xml success_node
+        (a == b).should == (b == a)
+      end
+
+      it 'should be transitive' do
+        a = SubmissionResult.from_xml success_node
+        b = SubmissionResult.from_xml success_node
+        c = SubmissionResult.from_xml success_node
+        (a == c).should == (a == b && b == c)
+      end
+
+      it 'should handle comparison to nil' do
+        a = SubmissionResult.from_xml success_node
+        (a == nil).should be false
+      end
+
+    end
+
+  end
+
+end

data/spec/mws/apis/feeds/transaction_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'nokogiri'
+
+module Mws::Apis::Feeds
+
+  describe Transaction do 
+
+    let(:submission_info) do
+      SubmissionInfo.from_xml(
+        Nokogiri::XML::Builder.new do
+          FeedSubmissionInfo {
+            FeedSubmissionId 5868304010
+            FeedType '_POST_PRODUCT_DATA_'
+            SubmittedDate '2012-10-16T21:19:08+00:00'
+            FeedProcessingStatus '_SUBMITTED_'
+          }
+        end.doc.root
+      )
+    end
+    
+    describe '.new' do
+
+      it 'should be able to create a transaction with no items' do
+        transaction = Transaction.new submission_info
+        transaction.id.should == "5868304010"
+        transaction.status.should == SubmissionInfo::Status.SUBMITTED.sym
+        transaction.type.should == Feed::Type.PRODUCT.sym
+        transaction.submitted.should == Time.parse('2012-10-16T21:19:08+00:00')
+        transaction.items.should be_empty
+      end
+
+      it 'should be able to create a transaction with items' do
+        transaction = Transaction.new submission_info do
+          item 1, '12345678', :update
+          item 2, '87654321', :update, :main
+          item 3, '87654321', :delete, :other
+        end
+
+        transaction.items.length.should == 3
+
+        item = transaction.items[0]
+        item.id.should == 1
+        item.sku.should == '12345678'
+        item.operation.should == :update
+        item.qualifier.should be_nil
+
+        item = transaction.items[1]
+        item.id.should == 2
+        item.sku.should == '87654321'
+        item.operation.should == :update
+        item.qualifier.should == :main
+
+        item = transaction.items[2]
+        item.id.should == 3
+        item.sku.should == '87654321'
+        item.operation.should == :delete
+        item.qualifier.should == :other
+      end
+
+    end
+
+  end
+
+end

data/spec/mws/apis/feeds/weight_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+module Mws::Apis::Feeds
+
+  describe Weight do
+
+    context '.new' do
+
+      it 'should default to pounds' do
+        weight = Weight.new 40
+        weight.amount.should == 40
+        weight.unit.should == :pounds
+      end
+
+      it 'should accept a valid unit override' do
+        weight = Weight.new 0, :ounces
+        weight.amount.should == 0
+        weight.unit.should == :ounces
+      end
+
+      it 'should validate the unit override' do
+        expect {
+          Weight.new 50, :cent
+        }.to raise_error Mws::Errors::ValidationError, "Invalid unit of measure 'cent'"
+      end
+
+    end
+
+    context '#to_xml' do
+
+      it 'should properly serialize to XML' do
+        weight = Weight.new 25, :grams
+        expected = Nokogiri::XML::Builder.new do
+          Weight 25, unitOfMeasure: 'GR'
+        end.doc.root.to_xml
+        weight.to_xml.should == expected
+      end
+
+    end
+
+  end
+  
+end

data/spec/mws/apis/orders_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+module Mws::Apis
+
+  describe Orders do
+
+  end
+
+end

data/spec/mws/connection_spec.rb

@@ -0,0 +1,331 @@
+require 'spec_helper'
+require 'nokogiri'
+
+module Mws
+
+  class Connection
+    attr_reader :scheme, :host, :merchant, :access, :secret
+    public :request, :response_for, :parse
+  end
+
+  describe Connection do
+
+    let(:defaults) {
+      {
+        merchant: 'GSWCJ4UBA31UTJ',
+        access: 'AYQAKIAJSCWMLYXAQ6K3', 
+        secret: 'Ubzq/NskSrW4m5ncq53kddzBej7O7IE5Yx9drGrX'
+      }
+    }
+
+    let(:connection) {
+      Mws.connect(defaults)
+    }
+
+    context '.new' do
+
+      it 'should default scheme to https' do
+        connection.scheme.should == 'https'
+      end
+
+      it 'should accept a custom scheme' do
+        Connection.new(defaults.merge(scheme: 'http')).scheme.should == 'http'
+      end
+
+      it 'should default host to mws.amazonservices.com' do
+        connection.host.should == 'mws.amazonservices.com'
+      end
+
+      it 'should accept a custom host' do
+        Connection.new(defaults.merge(host: 'mws.amazonservices.uk')).host.should == 'mws.amazonservices.uk'
+      end
+
+      it 'should require a merchant identifier' do
+        expect {
+          Connection.new(
+            access: defaults[:access],
+            secret: defaults[:secret]
+          )
+        }.to raise_error Mws::Errors::ValidationError, 'A merchant identifier must be specified.'
+      end
+
+      it 'should accept a merchant identifier' do
+        connection.merchant.should == 'GSWCJ4UBA31UTJ'
+      end
+
+      it 'should require an access key' do
+        expect { 
+          Connection.new(
+            merchant: defaults[:merchant], 
+            secret: defaults[:secret]
+          )
+        }.to raise_error Mws::Errors::ValidationError, 'An access key must be specified.'
+      end
+
+      it 'should accept an access key' do
+        connection.access.should == 'AYQAKIAJSCWMLYXAQ6K3'
+      end
+
+      it 'should require a secret key' do
+        expect { 
+          Connection.new(
+            merchant: defaults[:merchant],
+            access: defaults[:access]
+          )
+        }.to raise_error Mws::Errors::ValidationError, 'A secret key must be specified.'
+      end
+
+      it 'should accept a secret key' do
+        connection.secret.should == 'Ubzq/NskSrW4m5ncq53kddzBej7O7IE5Yx9drGrX'
+      end
+
+    end
+
+    context '#get' do
+
+      it 'should appropriately delegate to #request' do
+        connection.should_receive(:request).with(:get, '/foo', { market: 'ATVPDKIKX0DER' }, nil, { version: 1 })
+        connection.get('/foo', { market: 'ATVPDKIKX0DER' }, { version: 1 })
+      end
+
+    end
+
+    context '#post' do
+
+      it 'should appropriately delegate to #request' do
+        connection.should_receive(:request).with(:post, '/foo', { market: 'ATVPDKIKX0DER' }, 'test_body', { version: 1 })
+        connection.post('/foo', { market: 'ATVPDKIKX0DER' }, 'test_body', { version: 1 })
+      end
+
+    end
+
+    context '#request' do
+
+      it 'should construct a query, signer and make the request' do
+        Query.should_receive(:new).with(
+          action: nil, 
+          version: nil, 
+          merchant: 'GSWCJ4UBA31UTJ', 
+          access: 'AYQAKIAJSCWMLYXAQ6K3', 
+          list_pattern: nil
+        ).and_return('the_query')
+        signer = double('signer')
+        Signer.should_receive(:new).with(
+          method: :get,
+          host: 'mws.amazonservices.com',
+          path: '/foo',
+          secret: 'Ubzq/NskSrW4m5ncq53kddzBej7O7IE5Yx9drGrX'
+        ).and_return(signer)
+        signer.should_receive(:sign).with('the_query').and_return('the_signed_query')
+        connection.should_receive(:response_for).with(:get, '/foo', 'the_signed_query', nil).and_return('the_response')
+        connection.should_receive(:parse).with('the_response', {})
+        connection.request(:get, '/foo', {}, nil, {})
+      end
+
+      it 'should merge additional request parameters into the query' do
+        connection = Connection.new(
+          merchant: 'GSWCJ4UBA31UTJ',
+          access: 'AYQAKIAJSCWMLYXAQ6K3',
+          secret: 'Ubzq/NskSrW4m5ncq53kddzBej7O7IE5Yx9drGrX'
+        )
+        Query.should_receive(:new).with(
+          action: nil, 
+          version: nil, 
+          merchant: 'GSWCJ4UBA31UTJ', 
+          access: 'AYQAKIAJSCWMLYXAQ6K3', 
+          list_pattern: nil,
+          foo: 'bar',
+          baz: 'quk'
+        ).and_return('the_query')
+        signer = double('signer')
+        Signer.should_receive(:new).with(
+          method: :get,
+          host: 'mws.amazonservices.com',
+          path: '/foo',
+          secret: 'Ubzq/NskSrW4m5ncq53kddzBej7O7IE5Yx9drGrX'
+        ).and_return(signer)
+        signer.should_receive(:sign).with('the_query').and_return('the_signed_query')
+        connection.should_receive(:response_for).with(:get, '/foo', 'the_signed_query', nil).and_return('the_response')
+        connection.should_receive(:parse).with('the_response', {})
+        connection.request(:get, '/foo', { foo: 'bar', baz: 'quk' }, nil, {})
+      end
+
+      it 'should accept overrides to action, version and list_pattern' do
+        Query.should_receive(:new).with(
+          action: 'SubmitFeed', 
+          version: '2009-01-01', 
+          merchant: 'GSWCJ4UBA31UTJ', 
+          access: 'AYQAKIAJSCWMLYXAQ6K3', 
+          list_pattern: 'a_list_pattern'
+        ).and_return('the_query')
+        signer = double('signer')
+        Signer.should_receive(:new).with(
+          method: :get,
+          host: 'mws.amazonservices.com',
+          path: '/foo',
+          secret: 'Ubzq/NskSrW4m5ncq53kddzBej7O7IE5Yx9drGrX'
+        ).and_return(signer)
+        signer.should_receive(:sign).with('the_query').and_return('the_signed_query')
+        connection.should_receive(:response_for).with(:get, '/foo', 'the_signed_query', nil).and_return('the_response')
+        connection.should_receive(:parse).with('the_response', { action: 'SubmitFeed', version: '2009-01-01' })
+        connection.request(:get, '/foo', {}, nil, { action: 'SubmitFeed', version: '2009-01-01', list_pattern: 'a_list_pattern' })
+      end
+
+    end
+
+    context '#parse' do
+      
+      it 'should parse error messages correctly' do
+        body = <<-XML
+        <?xml version="1.0"?>
+        <ErrorResponse xmlns="https://mws.amazonservices.com/Orders/2011-01-01">
+          <Error>
+            <Type>Sender</Type>
+            <Code>InvalidParameterValue</Code>
+            <Message>CreatedAfter or LastUpdatedAfter must be specified</Message>
+          </Error>
+          <RequestId>fb03503e-97e3-4ed1-88e9-d93f4d2111c1</RequestId>
+        </ErrorResponse>
+        XML
+        expect { connection.parse(body, {}) }.to raise_error do | error | 
+          error.should be_a Errors::ServerError
+          error.type.should == 'Sender'
+          error.code.should == 'InvalidParameterValue'
+          error.message.should == 'CreatedAfter or LastUpdatedAfter must be specified'
+          error.details.should == 'None'
+        end
+      end
+
+      it 'should parse result based on custom action' do
+        body = <<-XML
+        <?xml version="1.0"?>
+        <ListOrdersResponse xmlns="https://mws.amazonservices.com/Orders/2011-01-01">
+          <ListOrdersResult>
+            <Orders/>
+            <CreatedBefore>2012-11-19T20:54:33Z</CreatedBefore>
+          </ListOrdersResult>
+          <ResponseMetadata>
+            <RequestId>931137cb-add7-4232-ac08-b701435c8447</RequestId>
+          </ResponseMetadata>
+        </ListOrdersResponse>
+        XML
+        result = connection.parse(body, action: 'ListOrders').name.should == 'ListOrdersResult'
+      end
+
+      it 'shoudl parse result base on custom xpath' do
+        body = <<-XML
+        <?xml version="1.0"?>
+        <ListOrdersResponse xmlns="https://mws.amazonservices.com/Orders/2011-01-01">
+          <ListOrdersResult>
+            <Orders/>
+            <CreatedBefore>2012-11-19T20:54:33Z</CreatedBefore>
+          </ListOrdersResult>
+          <ResponseMetadata>
+            <RequestId>931137cb-add7-4232-ac08-b701435c8447</RequestId>
+          </ResponseMetadata>
+        </ListOrdersResponse>
+        XML
+        result = connection.parse(body, xpath: '/ListOrdersResponse/ListOrdersResult').name.should == 'ListOrdersResult'
+      end
+
+    end
+
+    context '#response_for' do
+
+      it 'should properly handle a secure get request' do
+        response = double(:response)
+        response.should_receive(:body).exactly(3).times.and_return('response_body')
+        http = double(:http)
+        http.should_receive(:request) do | req |
+          req.should be_a Net::HTTP::Get
+          req.method.should == 'GET'
+          req.path.should == '/?foo=bar'
+          req['User-Agent'].should == 'MWS Connect/0.0.1 (Language=Ruby)'
+          req['Accept-Encoding'].should == 'text/xml'
+          response
+        end
+        Net::HTTP.should_receive(:start).with('mws.amazonservices.com', 443, use_ssl: true).and_yield(http)
+        connection.response_for(:get, '/', 'foo=bar', nil).should == 'response_body'
+      end
+
+      it 'should properly handle an insecure get request' do
+        connection = Connection.new(defaults.merge(scheme: 'http'))
+        response = double(:response)
+        response.should_receive(:body).exactly(3).times.and_return('response_body')
+        http = double(:http)
+        http.should_receive(:request) do | req |
+          req.should be_a Net::HTTP::Get
+          req.method.should == 'GET'
+          req.path.should == '/?foo=bar'
+          req['User-Agent'].should == 'MWS Connect/0.0.1 (Language=Ruby)'
+          req['Accept-Encoding'].should == 'text/xml'
+          response
+        end
+        Net::HTTP.should_receive(:start).with('mws.amazonservices.com', 80, use_ssl: false).and_yield(http)
+        connection.response_for(:get, '/', 'foo=bar', nil).should == 'response_body'
+      end
+
+      it 'should properly handle requests with transport level errors' do
+        response = double(:response)
+        response.should_receive(:body).and_return(nil)
+        response.should_receive(:code).and_return(500)
+        response.should_receive(:msg).and_return('Internal Server Error')
+        http = double(:http)
+        http.should_receive(:request) do | req |
+          req.should be_a Net::HTTP::Get
+          req.method.should == 'GET'
+          req.path.should == '/?foo=bar'
+          req['User-Agent'].should == 'MWS Connect/0.0.1 (Language=Ruby)'
+          req['Accept-Encoding'].should == 'text/xml'
+          response
+        end
+        Net::HTTP.should_receive(:start).with('mws.amazonservices.com', 443, use_ssl: true).and_yield(http)
+        expect { connection.response_for(:get, '/', 'foo=bar', nil) }.to raise_error do | error |
+          error.should be_a Errors::ServerError
+          error.type.should == 'Server'
+          error.code.should == 500
+          error.message.should == 'Internal Server Error'
+          error.detail.should == 'None'
+        end
+      end
+
+      it 'should properly handle a post without a body' do
+        response = double(:response)
+        response.should_receive(:body).exactly(3).times.and_return('response_body')
+        http = double(:http)
+        http.should_receive(:request) do | req |
+          req.should be_a Net::HTTP::Post
+          req.method.should == 'POST'
+          req.path.should == '/?foo=bar'
+          req['User-Agent'].should == 'MWS Connect/0.0.1 (Language=Ruby)'
+          req['Accept-Encoding'].should == 'text/xml'
+          response
+        end
+        Net::HTTP.should_receive(:start).with('mws.amazonservices.com', 443, use_ssl: true).and_yield(http)
+        connection.response_for(:post, '/', 'foo=bar', nil).should == 'response_body'
+      end
+
+      it 'should properly handle a post with a body' do
+        response = double(:response)
+        response.should_receive(:body).exactly(3).times.and_return('response_body')
+        http = double(:http)
+        http.should_receive(:request) do | req |
+          req.should be_a Net::HTTP::Post
+          req.method.should == 'POST'
+          req.path.should == '/?foo=bar'
+          req.content_type.should == 'text/xml'
+          req.body.should == 'request_body'
+          req['Content-MD5'] = Digest::MD5.base64digest('request_body').strip
+          req['User-Agent'].should == 'MWS Connect/0.0.1 (Language=Ruby)'
+          req['Accept-Encoding'].should == 'text/xml'
+          response
+        end
+        Net::HTTP.should_receive(:start).with('mws.amazonservices.com', 443, use_ssl: true).and_yield(http)
+        connection.response_for(:post, '/', 'foo=bar', 'request_body').should == 'response_body'
+      end
+
+    end
+
+  end
+
+end