mws-connect 0.0.1

data/spec/mws/enum_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+module Mws
+
+  describe Enum do
+
+    let (:options) do
+      {
+        pending: 'Pending',
+        unshipped: [ 'Unshipped', 'PartiallyShipped' ],
+        shipped: 'Shipped',
+        invoice_unconfirmed: 'InvoiceUnconfirmed',
+        cancelled: 'Cancelled',
+        unfulfillable: 'Unfulfillable'
+      }
+    end
+
+    before(:all) do
+      OrderStatus = Enum.for options
+    end
+
+    it 'should not allow instance creation via new' do
+      expect { Enum.new }.to raise_error NoMethodError
+    end
+
+    context '.for' do
+
+      it 'should construct a pseudo-constant accessor for each provided symbol' do
+        options.each do | key, value |
+          OrderStatus.send(key.to_s.upcase.to_sym).should_not be nil
+        end
+      end
+
+      it 'should not share pseudo-constants between enumeration instances' do
+        EnumOne = Enum.for( foo: 'Foo', bar: 'Bar', baz: 'Baz' )
+        EnumTwo = Enum.for( bar: 'BAR', baz: 'BAZ', quk: 'QUK' )
+        expect { EnumOne.QUK }.to raise_error NoMethodError
+        expect { EnumTwo.FOO }.to raise_error NoMethodError
+        EnumOne.BAR.should_not == EnumTwo.BAR
+      end
+
+    end
+
+    context '.sym_reader' do
+
+      class HasEnumAttrs
+
+        EnumOne = Enum.for( foo: 'Foo', bar: 'Bar', baz: 'Baz' )
+
+        EnumTwo = Enum.for( bar: 'BAR', baz: 'BAZ', quk: 'QUK' )
+
+        Enum.sym_reader self, :one, :two
+
+        def initialize(one, two)
+          @one = EnumOne.for(one)
+          @two = EnumTwo.for(two)
+        end
+
+      end
+
+      it 'should synthesize a attr_reader that exposes an enum entry as a symbol' do
+        it = HasEnumAttrs.new(:foo, :quk)
+        it.send(:instance_variable_get, '@one').should == HasEnumAttrs::EnumOne.FOO
+        it.one.should == :foo
+        it.send(:instance_variable_get, '@two').should == HasEnumAttrs::EnumTwo.QUK
+        it.two.should == :quk
+      end
+
+      it 'should synthesize attr_readers that are null safe' do
+        it = HasEnumAttrs.new(:quk, :foo)
+        it.one.should be nil
+        it.two.should be nil
+      end
+
+    end
+
+    context '#for' do
+
+      it 'should be able to find an enum entry from a symbol' do
+        OrderStatus.for(:pending).should == OrderStatus.PENDING
+      end
+
+      it 'should be able to find an enum entry from a string' do
+        OrderStatus.for('Pending').should == OrderStatus.PENDING
+      end
+
+      it 'should be able to find an enum entry from an enum entry' do
+        OrderStatus.for(OrderStatus.PENDING).should == OrderStatus.PENDING
+      end
+      
+    end
+
+    context '#sym' do
+
+      it 'should return nil for nil value' do
+        OrderStatus.sym(nil).should be nil
+      end
+
+      it 'should return nil for an unknown value' do
+        OrderStatus.sym('UnknownValue').should be nil
+      end
+
+      it 'should provide the symbol for a given value' do
+        OrderStatus.sym('Pending').should == :pending
+        OrderStatus.sym('Unshipped').should == :unshipped
+        OrderStatus.sym('PartiallyShipped').should == :unshipped
+        OrderStatus.sym('Shipped').should == :shipped
+        OrderStatus.sym('Cancelled').should == :cancelled
+        OrderStatus.sym('Unfulfillable').should == :unfulfillable
+      end
+
+    end
+
+    context '#val' do
+
+      it 'should return nil for nil symbol' do
+        OrderStatus.val(nil).should be nil
+      end
+
+      it 'should return nil for an unknown sumbol' do
+        OrderStatus.val(:unknown).should be nil
+      end
+
+      it 'should provide the value for a given symbol' do
+        OrderStatus.val(:pending).should == 'Pending'
+        OrderStatus.val(:unshipped).should == [ 'Unshipped', 'PartiallyShipped' ]
+        OrderStatus.val(:shipped).should == 'Shipped'
+        OrderStatus.val(:cancelled).should == 'Cancelled'
+        OrderStatus.val(:unfulfillable).should == 'Unfulfillable'
+      end
+
+    end
+
+    context '#syms' do
+
+      it 'should provide the set of symbols' do
+        OrderStatus.syms.should == options.keys
+      end
+
+    end
+
+    context '#vals' do
+
+      it 'should provide the list of values' do
+        OrderStatus.vals.should == options.values.flatten
+      end
+
+    end
+
+    it 'should be able to provide a symbol for an entry' do
+      OrderStatus.PENDING.sym.should == :pending
+    end
+
+    it 'should be able to provide a value for an enum entry' do
+      OrderStatus.PENDING.val.should == 'Pending'
+    end
+
+    it 'should be able to handle multivalued enum entries' do
+      OrderStatus.for(:unshipped).should == OrderStatus.UNSHIPPED
+      OrderStatus.for('Unshipped').should == OrderStatus.UNSHIPPED
+      OrderStatus.for('PartiallyShipped').should == OrderStatus.UNSHIPPED
+    end
+    
+  end
+
+end

data/spec/mws/query_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+module Mws
+
+  class Query
+    attr_reader :params
+  end
+
+  describe Query do
+    
+    let(:defaults) do
+      {
+        access: 'Q6K3SCWMLYAKIAJXAAYQ', 
+        merchant: 'J4UBGSWCA31UTJ', 
+        markets: [ 'ATVPDKIKX0DER', 'KIKX0DERATVPD' ],
+        last_updated_after: 4.hours.ago
+      }
+    end
+
+    let(:query) {  Query.new defaults }
+
+    it 'should default SignatureMethod to HmacSHA256' do
+      query.params['SignatureMethod'].should == 'HmacSHA256'
+    end
+
+    it 'should default SignatureVersion to 2' do
+      query.params['SignatureVersion'].should == '2'
+    end
+
+    it 'should default Timestamp to now in iso8601 format' do
+      time = URI.decode(query.params['Timestamp']).should == Time.now.iso8601
+    end
+
+    it 'should accept overrides to SignatureMethod' do
+      Query.new(defaults.merge(signature_method: 'HmacSHA1')).params['SignatureMethod'].should == 'HmacSHA1'
+    end
+
+    it 'should accept overrides to SignatureVersion' do
+      Query.new(defaults.merge(signature_version: 3)).params['SignatureVersion'].should == '3'
+    end
+
+    it 'should accept overrides to Timestamp' do
+      time = 4.hours.ago
+      query = Query.new(defaults.merge(timestamp: time))
+      URI.decode(query.params['Timestamp']).should == time.iso8601
+    end
+
+    it 'should translate access to AWSAccessKeyId' do
+      access_key = 'Q6K3SCWMLYAKIAJXAAYQ'
+      Query.new(defaults.merge(access: access_key)).params['AWSAccessKeyId'].should == access_key
+    end
+
+    it 'should translate merchant or seller to seller_id' do
+      merchant = 'J4UBGSWCA31UTJ'
+      queries = [ Query.new(defaults.merge(merchant: merchant)), Query.new(defaults.merge(seller: merchant)) ]
+      queries.each do | query |
+        query.params['SellerId'].should == merchant
+      end
+    end
+
+    it 'should gracefully handle empty markets list' do
+      Query.new(defaults.merge(markets: [])).params['MarketplaceIdList.Id.1'].should be nil
+    end
+
+    it 'should translate single market to MarketplaceIdList.Id.1' do
+      market = 'ATVPDKIKX0DER'
+      Query.new(defaults.merge(markets: [ market ])).params['MarketplaceIdList.Id.1'].should == market
+    end
+
+    it 'should translate multiple markets to MarketplaceIdList.Id.*' do
+      markets = [ 'ATVPDKIKX0DER', 'KIKX0DERATVPD' ]
+      query = Query.new defaults.merge(markets: markets)
+      markets.each_with_index do | market, index |
+        query.params["MarketplaceIdList.Id.#{index + 1}"].should == market
+      end
+    end
+
+    it 'should allow for overriding the list representation strategy via list_pattern' do
+      markets = [ 'ATVPDKIKX0DER', 'KIKX0DERATVPD' ]
+      list_pattern = '%{key}[%<index>d]'
+      query = Query.new defaults.merge(markets: markets, list_pattern: list_pattern)
+      markets.each_with_index do | market, index |
+        query.params["MarketplaceId[#{index + 1}]"].should == market
+      end
+    end
+
+    it 'should sort query parameters lexicographically' do
+      query.params.inject('') do | prev, entry |
+        entry.first.should be > prev
+        entry.first
+      end
+    end
+
+    it 'should convert to a compliant query string' do
+      query_string = query.to_s
+      query_string.split('&').each do | entry |
+        key, value = entry.split '='
+        query.params[key].should == value
+      end
+    end
+
+  end
+
+end

data/spec/mws/serializer_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+
+module Mws
+
+  describe Serializer do
+
+    let(:from) { 1.day.from_now }
+    let(:to) { 3.months.from_now }
+    let(:regular_price) { 21.99 }
+    let(:sale_price) { 14.99 }
+
+    context '.tree' do
+
+      it 'should properly serialize without a parent' do
+        expected = Nokogiri::XML::Builder.new {
+          Sale {
+            StartDate from.iso8601
+            EndDate to.iso8601
+            SalePrice sale_price, currency: 'USD'
+          }
+        }.doc.root.to_xml
+        actual = Serializer.tree 'Sale', nil do | xml |
+          xml.StartDate from.iso8601
+          xml.EndDate to.iso8601
+          xml.SalePrice sale_price, currency: 'USD'
+        end
+        actual.should == expected
+      end
+
+      it 'should properly serialize with a parent' do
+        sku = '7890123456'
+        expected = Nokogiri::XML::Builder.new {
+          Price {
+            SKU sku
+            StandardPrice regular_price, currency: 'USD'
+            Sale {
+              StartDate from.iso8601
+              EndDate to.iso8601
+              SalePrice sale_price, currency: 'USD'
+            }
+          }
+        }.to_xml
+        actual = Nokogiri::XML::Builder.new {
+          Price {
+            SKU sku
+            StandardPrice regular_price, currency: 'USD'
+            actual = Serializer.tree 'Sale', self do | xml |
+              xml.StartDate from.iso8601
+              xml.EndDate to.iso8601
+              xml.SalePrice sale_price, currency: 'USD'
+            end
+          }
+        }.to_xml
+        actual.should == expected
+      end
+
+    end
+
+    context '.leaf' do
+
+      it 'should properly serialize without a parent' do
+        expected = Nokogiri::XML::Builder.new {
+          SalePrice sale_price, currency: 'USD'
+        }.doc.root.to_xml
+        actual = Serializer.leaf 'SalePrice', nil, sale_price, currency: 'USD'
+        actual.should == expected
+      end
+
+      it 'should properly serialize with a parent' do
+        expected = Nokogiri::XML::Builder.new {
+          Sale {
+            StartDate from.iso8601
+            EndDate to.iso8601
+            SalePrice sale_price, currency: 'USD'
+          }
+        }.to_xml
+        actual = Nokogiri::XML::Builder.new {
+          Sale {
+            StartDate from.iso8601
+            EndDate to.iso8601
+            Serializer.leaf 'SalePrice', self, sale_price, currency: 'USD'
+          }
+        }.to_xml
+        actual.should == expected
+      end
+
+    end
+
+    context '#xml_for' do
+
+      let(:data) do
+        {
+          foo: 'Bar',
+          foo_bar: {
+            baz_quk: 'FooBarBazQuk'
+          },
+          baz: [
+            'Foo',
+            'Bar',
+            'Baz',
+            'Quk'
+          ],
+          price: Mws::Money(regular_price, :usd)
+        }
+      end
+
+      it 'should work with no exceptions' do
+        expected = Nokogiri::XML::Builder.new {
+          Data {
+            Foo 'Bar'
+            FooBar {
+              BazQuk 'FooBarBazQuk'
+            }
+            Baz 'Foo'
+            Baz 'Bar'
+            Baz 'Baz'
+            Baz 'Quk'
+            Price regular_price, currency: 'USD'
+          }
+        }.to_xml
+        actual = Nokogiri::XML::Builder.new
+        Serializer.new.xml_for('Data', data, actual)
+        actual.to_xml.should == expected
+      end
+
+      it 'should work with exceptions' do
+        expected = Nokogiri::XML::Builder.new {
+          Data {
+            FOO 'Bar'
+            FooBar {
+              BazQuk 'FooBarBazQuk'
+            }
+            BaZ 'Foo'
+            BaZ 'Bar'
+            BaZ 'Baz'
+            BaZ 'Quk'
+            Price regular_price, currency: 'USD'
+          }
+        }.to_xml
+        actual = Nokogiri::XML::Builder.new
+        Serializer.new(foo: 'FOO', baz: 'BaZ').xml_for('Data', data, actual)
+        actual.to_xml.should == expected
+      end
+
+    end
+
+    context '#hash_for' do
+
+      let(:xml) do
+        Nokogiri::XML::Builder.new {
+          Data {
+            FOO 'Bar'
+            FooBar {
+              BazQuk 'FooBarBazQuk'
+            }
+            BaZ 'Foo'
+            BaZ 'Bar'
+            BaZ 'Baz'
+            BaZ 'Quk'
+            Price regular_price, currency: 'USD'
+          }
+        }.doc.root
+      end
+
+      it 'should work with exceptions' do
+        expected = {
+          foo: 'Bar',
+          foo_bar: {
+            baz_quk: 'FooBarBazQuk'
+          },
+          baz: [
+            'Foo',
+            'Bar',
+            'Baz',
+            'Quk'
+          ],
+          price: regular_price.to_s
+        }
+        actual = Serializer.new(foo: 'FOO', baz: 'BaZ').hash_for(xml, nil)
+        actual.should == expected
+      end
+
+    end
+
+  end
+
+end