mws-rb 0.0.1

data/spec/mws-rb/api/base_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe MWS::API::Base do
+  let(:connection) {MWS::Connection.new({
+    aws_access_key_id: "access key",
+    aws_secret_access_key: "secret key",
+    seller_id: "seller id"
+  })}
+
+  let(:base) {MWS::API::Base.new(connection)}
+
+  it "hould receive a connection object" do
+    base.connection.should eq(connection)
+  end
+
+  it "should respond to .call" do
+    base.should respond_to(:call)
+  end
+
+  it "should respond to :uri and :version and :verb" do
+    base.should respond_to(:uri)
+    base.should respond_to(:version)
+    base.should respond_to(:verb)
+  end
+
+  it "should set :verb to :get as default" do
+    base.verb.should eq(:get)
+  end
+
+  describe "method_missing to call actions" do
+    class TestApi < MWS::API::Base
+      Actions = [:test_action]
+      def initialize(connection)
+        @uri = "/Products/2011-10-01"
+        @version = "2011-10-01"
+        super(connection)
+      end
+    end
+
+    let(:test_api) {TestApi.new(connection)}
+    before(:each) {HTTParty.stub(:get).and_return({})}
+
+    it "should not raise exception if Actions contain the action name" do
+      expect {test_api.test_action}.to_not raise_error
+    end
+
+    it "should raise exception if Actions do not contain the action name" do
+      expect {test_api.action_not_found}.to raise_error
+    end
+  end
+end

data/spec/mws-rb/api/feeds/envelope_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe MWS::API::Feeds::Envelope do
+  it "should validate the envelope" do
+    expect {
+      MWS::API::Feeds::Envelope.new(message_type: "InvalidMessageType", message:{"InvalidItem" => "Invalid"})
+    }.to raise_error
+  end
+
+  it "should skip validation when param skip_schema_validation is true" do
+    expect {
+      MWS::API::Feeds::Envelope.new(message_type: "InvalidMessageType", message:{"InvalidItem" => "Invalid"}, skip_schema_validation: true)
+    }.to_not raise_error
+  end
+
+  it "should remove array items" do
+    envelope = MWS::API::Feeds::Envelope.new(
+                message_type: "InvalidMessageType", 
+                message:{
+                  "Items" => [{item_1: "1"}, {item_2: "2"}],
+                  "Inventories" => [{inventory_1: "1"}]
+                },
+                skip_schema_validation: true)
+
+    envelope.to_s.include?("Items").should == false
+    envelope.to_s.include?("Inventories").should == false
+    envelope.to_s.include?("array").should == false
+  end
+end

data/spec/mws-rb/api/feeds_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe MWS::API::Feeds do
+  let(:connection) {MWS::Connection.new({
+    aws_access_key_id: "access key",
+    aws_secret_access_key: "secret key",
+    seller_id: "seller id"
+  })}
+
+  let(:feeds) {MWS::API::Feeds.new(connection)}
+
+  it "should inheritance from MWS::API::Base" do
+    MWS::API::Feeds.superclass.should eq(MWS::API::Base)
+  end
+
+  it "should set the right :uri" do
+    feeds.uri.should eq("/")
+  end
+
+  it "should set the right :version" do
+    feeds.version.should eq("2009-01-01")
+  end
+end

data/spec/mws-rb/api/fulfillment_inbound_shipment_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe MWS::API::FulfillmentInboundShipment do
+  let(:connection) {MWS::Connection.new({
+    aws_access_key_id: "access key",
+    aws_secret_access_key: "secret key",
+    seller_id: "seller id"
+  })}
+
+  let(:fulfillment_inbound_shipment) {MWS::API::FulfillmentInboundShipment.new(connection)}
+
+  it "should inheritance from MWS::API::Base" do
+    MWS::API::Feeds.superclass.should eq(MWS::API::Base)
+  end
+
+  it "should set the right :uri" do
+    fulfillment_inbound_shipment.uri.should eq("/FulfillmentInboundShipment/2010-10-01")
+  end
+
+  it "should set the right :version" do
+    fulfillment_inbound_shipment.version.should eq("2010-10-01")
+  end
+end

data/spec/mws-rb/api/fulfillment_inventory_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe MWS::API::FulfillmentInventory do
+  let(:connection) {MWS::Connection.new({
+    aws_access_key_id: "access key",
+    aws_secret_access_key: "secret key",
+    seller_id: "seller id"
+  })}
+
+  let(:fulfillment_inventory) {MWS::API::FulfillmentInventory.new(connection)}
+
+  it "should inheritance from MWS::API::Base" do
+    MWS::API::FulfillmentInventory.superclass.should eq(MWS::API::Base)
+  end
+
+  it "should set the right :uri" do
+    fulfillment_inventory.uri.should eq("/FulfillmentInventory/2010-10-01")
+  end
+
+  it "should set the right :version" do
+    fulfillment_inventory.version.should eq("2010-10-01")
+  end
+end

data/spec/mws-rb/api/fulfillment_outbound_shipment_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe MWS::API::FulfillmentOutboundShipment do
+  let(:connection) {MWS::Connection.new({
+    aws_access_key_id: "access key",
+    aws_secret_access_key: "secret key",
+    seller_id: "seller id"
+  })}
+
+  let(:fulfillment_outbound_shipment) {MWS::API::FulfillmentOutboundShipment.new(connection)}
+
+  it "should inheritance from MWS::API::Base" do
+    MWS::API::FulfillmentOutboundShipment.superclass.should eq(MWS::API::Base)
+  end
+
+  it "should set the right :uri" do
+    fulfillment_outbound_shipment.uri.should eq("/FulfillmentOutboundShipment/2010-10-01")
+  end
+
+  it "should set the right :version" do
+    fulfillment_outbound_shipment.version.should eq("2010-10-01")
+  end
+end

data/spec/mws-rb/api/orders_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe MWS::API::Orders do
+
+  let(:connection) {MWS::Connection.new({
+    aws_access_key_id: "access key",
+    aws_secret_access_key: "secret key",
+    seller_id: "seller id"
+  })}
+
+  let(:orders) {MWS::API::Orders.new(connection)}
+
+  it "should inheritance from MWS::API::Base" do
+    MWS::API::Orders.superclass.should eq(MWS::API::Base)
+  end
+
+  it "should set the right :uri" do
+    orders.uri.should eq("/Orders/2011-01-01")
+  end
+
+  it "should set the right :version" do
+    orders.version.should eq("2011-01-01")
+  end
+end

data/spec/mws-rb/api/products_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe MWS::API::Products do
+
+  let(:connection) {MWS::Connection.new({
+    aws_access_key_id: "access key",
+    aws_secret_access_key: "secret key",
+    seller_id: "seller id"
+  })}
+
+  let(:orders) {MWS::API::Products.new(connection)}
+
+  it "should inheritance from MWS::API::Base" do
+    MWS::API::Products.superclass.should eq(MWS::API::Base)
+  end
+
+  it "should set the right :uri" do
+    orders.uri.should eq("/Products/2011-10-01")
+  end
+
+  it "should set the right :version" do
+    orders.version.should eq("2011-10-01")
+  end
+end

data/spec/mws-rb/api/recommendations_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe MWS::API::Recommendations do
+
+  let(:connection) {MWS::Connection.new({
+    aws_access_key_id: "access key",
+    aws_secret_access_key: "secret key",
+    seller_id: "seller id"
+  })}
+
+  let(:recommendations) {MWS::API::Recommendations.new(connection)}
+
+  it "should inheritance from MWS::API::Base" do
+    MWS::API::Recommendations.superclass.should eq(MWS::API::Base)
+  end
+
+  it "should set the right :uri" do
+    recommendations.uri.should eq("/Recommendations/2013-04-01")
+  end
+
+  it "should set the right :version" do
+    recommendations.version.should eq("2013-04-01")
+  end
+end

data/spec/mws-rb/api/reports_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe MWS::API::Reports do
+
+  let(:connection) {MWS::Connection.new({
+    aws_access_key_id: "access key",
+    aws_secret_access_key: "secret key",
+    seller_id: "seller id"
+  })}
+
+  let(:reports) {MWS::API::Reports.new(connection)}
+
+  it "should inheritance from MWS::API::Base" do
+    MWS::API::Reports.superclass.should eq(MWS::API::Base)
+  end
+
+  it "should set the right :uri" do
+    reports.uri.should eq("/")
+  end
+
+  it "should set the right :version" do
+    reports.version.should eq("2009-01-01")
+  end
+end

data/spec/mws-rb/api/sellers_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe MWS::API::Sellers do
+
+  let(:connection) {MWS::Connection.new({
+    aws_access_key_id: "access key",
+    aws_secret_access_key: "secret key",
+    seller_id: "seller id"
+  })}
+
+  let(:sellers) {MWS::API::Sellers.new(connection)}
+
+  it "should inheritance from MWS::API::Base" do
+    MWS::API::Sellers.superclass.should eq(MWS::API::Base)
+  end
+
+  it "should set the right :uri" do
+    sellers.uri.should eq("/Sellers/2011-07-01")
+  end
+
+  it "should set the right :version" do
+    sellers.version.should eq("2011-07-01")
+  end
+
+  it "should set the right :version" do
+    sellers.verb.should eq(:post)
+  end
+end

data/spec/mws-rb/connection_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe MWS::Connection do
+
+  let(:subject) {MWS::Connection.new({
+    aws_access_key_id: "access key",
+    aws_secret_access_key: "secret key",
+    seller_id: "seller id"
+  })}
+
+  it "should have a default host" do
+    subject.host.should eq("mws.amazonservices.com")
+  end
+
+  describe "call the right apis" do
+    it "should return Feeds when calling .feeds" do
+      subject.feeds.instance_of?(MWS::API::Feeds).should == true
+    end
+
+    it "should return FulfillmentInboundShipment when calling .fulfillment_inbound_shipment" do
+      subject.fulfillment_inbound_shipment.instance_of?(MWS::API::FulfillmentInboundShipment).should == true
+    end
+
+    it "should return FulfillmentInventory when calling .fulfillment_inventory" do
+      subject.fulfillment_inventory.instance_of?(MWS::API::FulfillmentInventory).should == true
+    end
+
+    it "should return FulfillmentOutboundShipment when calling .fulfillment_outbound_shipment" do
+      subject.fulfillment_outbound_shipment.instance_of?(MWS::API::FulfillmentOutboundShipment).should == true
+    end
+
+    it "should return Orders when calling .orders" do
+      subject.orders.instance_of?(MWS::API::Orders).should == true
+    end
+
+    it "should return Products when calling .products" do
+      subject.products.instance_of?(MWS::API::Products).should == true
+    end
+
+    it "should return Recommendations when calling .recommendations" do
+      subject.recommendations.instance_of?(MWS::API::Recommendations).should == true
+    end
+
+    it "should return Reports when calling .reports" do
+      subject.reports.instance_of?(MWS::API::Reports).should == true
+    end
+
+    it "should return Sellers when calling .sellers" do
+      subject.sellers.instance_of?(MWS::API::Sellers).should == true
+    end
+  end
+
+  describe "Validations" do
+    it "should raise argument error if key, secret or seller_id is not provided" do
+      expect {MWS::Connection.new}.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/mws-rb/mws_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe MWS do
+  it "should return a connection on initializer" do
+    subject.new(
+      aws_access_key_id: "access key",
+      aws_secret_access_key: "secret key",
+      seller_id: "seller id"
+    ).class.should eq(MWS::Connection)
+  end
+end

data/spec/mws-rb/query_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe MWS::Query do
+  let(:query_params) {{
+    verb: "GET",
+    uri: "/",
+    host: "mws-eu.amazonservices.com",
+    aws_access_key_id: "key",
+    aws_secret_access_key: "secret",
+    action: "ListOrders",
+    seller_id: "Seller ID",
+    version: "2010-01-01",
+    timestamp: "2013-01-01T00:00:00-02:00"
+  }}
+
+  let(:query) {MWS::Query.new(query_params)}
+
+  describe "Initialization" do
+    it "should create a MWS::Query object" do
+      subject.class.should eq(MWS::Query)
+    end
+
+    it "should have some default params" do
+      subject.uri.should eq("/")
+      subject.verb.should eq("GET")
+      subject.signature_method.should eq("HmacSHA256")
+      subject.signature_version.should eq(2)
+      subject.timestamp.class.should eq(Time)
+    end
+  end
+
+  describe "Build query" do
+    it "should build a simple query" do
+      generated_query = "AWSAccessKeyId=key&Action=ListOrders&SellerId=Seller+ID&SignatureMethod=HmacSHA256&SignatureVersion=2&Timestamp=2013-01-01T00%3A00%3A00-02%3A00&Version=2010-01-01"
+      query.build_query.should eq(generated_query)
+    end
+
+    it "should build a query with a signature" do
+      query.build_query("signature").include?("Signature=signature").should eq true
+    end
+
+    it "should be a query with custom params" do
+      builded_query = MWS::Query.new(query_params.merge(params: {custom_param: "custom"})).build_query
+      builded_query.should include("CustomParam=custom")
+    end
+  end
+
+  describe "canonical string" do
+    it "should generate a canonical string" do
+      canonical = "GET\nmws-eu.amazonservices.com\n/\nAWSAccessKeyId=key&Action=ListOrders&SellerId=Seller+ID&SignatureMethod=HmacSHA256&SignatureVersion=2&Timestamp=2013-01-01T00%3A00%3A00-02%3A00&Version=2010-01-01"
+      query.canonical.should eq(canonical)
+    end
+  end
+
+  describe "signature" do
+    it "should generate a valid signature" do
+      query.signature.should eq("7XZO1dSv7BHElkee33Rt7L5PNFiBET13pg3pOWKeoo0=")
+    end
+  end
+
+  describe "request_uri" do
+    it "should generate a valid request uri" do
+      request_uri = "https://mws-eu.amazonservices.com/?AWSAccessKeyId=key&Action=ListOrders&SellerId=Seller+ID&Signature=7XZO1dSv7BHElkee33Rt7L5PNFiBET13pg3pOWKeoo0%3D&SignatureMethod=HmacSHA256&SignatureVersion=2&Timestamp=2013-01-01T00%3A00%3A00-02%3A00&Version=2010-01-01"
+      query.request_uri.should eq(request_uri)
+    end
+  end
+
+  describe MWS::Query::Helpers do
+    subject {MWS::Query::Helpers}
+
+    describe "escape_date_time_params(params={})" do
+      let(:time) {Time.new(2013, 01, 01)}
+
+      it "should escape a simple hash" do
+        subject.escape_date_time_params(time: time).should eq({time: time.iso8601})
+      end
+
+      it "should escape a nested hash" do
+        subject.escape_date_time_params(time: {time: time}).should eq({time: {time: time.iso8601}})
+      end
+    end
+
+    describe "camelize_keys(parmas={})" do
+      it "should camelize a simple hash" do
+        subject.camelize_keys(new_key: "value").should eq("NewKey" => "value")
+      end
+
+      it "should camelize a nested hash" do
+        subject.camelize_keys(key: {key: "value"}).should eq("Key" => {"Key" => "value"})
+      end
+    end
+
+    describe "make_structured_lists" do
+      it "should return a new structured list" do
+        structured_list = subject.make_structured_lists(ids_list: {label: "Id.id", values: [1,2]})
+        structured_list.should eq("Id.id.1" => 1, "Id.id.2" => 2)
+      end
+
+      it "should return the same hash if there's no list params" do
+        structured_list = subject.make_structured_lists(test: "test")
+        structured_list.should eq(test: "test")
+      end
+
+      it "should return a hash with structured lists and normal values" do
+        structured_list = subject.make_structured_lists(test: "test", id_list: {label: "Id.id", values: [1]})
+        structured_list.should eq(test: "test", "Id.id.1" => 1)
+      end
+    end
+  end
+end