walmart_open 0.0.1

data/lib/walmart_open/search_results.rb

@@ -0,0 +1,25 @@
+require "walmart_open/item"
+
+module WalmartOpen
+  class SearchResults
+    attr_reader :query,
+                :total,
+                :items,
+                :start,
+                :page
+
+    def initialize(response)
+      @query = response["query"]
+      @total = response["totalResults"]
+      @start = response["start"]
+      # TODO: set the page!
+      # @page = ...
+
+      @items = []
+
+      response["items"].each do |item|
+        @items << Item.new(item)
+      end
+    end
+  end
+end

data/lib/walmart_open/shipping_address.rb

@@ -0,0 +1,36 @@
+module WalmartOpen
+  class ShippingAddress
+    API_ATTRIBUTES_MAPPING = {
+        street1:  "street1",
+        street2:  "street2",
+        city:     "city",
+        state:    "state",
+        zipcode:  "zipcode",
+        country:  "country",
+    }
+
+    API_ATTRIBUTES_MAPPING.each_value do |attr_name|
+      attr_reader attr_name
+    end
+
+    attr_reader :raw_attributes
+
+    def initialize(params)
+      @raw_attributes = params
+      extract_known_attributes
+    end
+
+    def valid?
+      !!(street1 && city && state && zipcode && country)
+    end
+
+    private
+    def extract_known_attributes
+      API_ATTRIBUTES_MAPPING.each do |api_attr, attr|
+        next unless raw_attributes.has_key?(api_attr)
+
+        instance_variable_set("@#{attr}", raw_attributes[api_attr])
+      end
+    end
+  end
+end

data/lib/walmart_open/version.rb

@@ -0,0 +1,3 @@
+module WalmartOpen
+  VERSION = "0.0.1"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require "pathname"
+ROOT_PATH = Pathname.new(__FILE__).join("../..").expand_path
+$LOAD_PATH.unshift(ROOT_PATH.join("lib"))
+
+RSpec.configure do |config|
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = "random"
+
+  # Disable the should syntax compeletely; we use the expect syntax only.
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/walmart_open/auth_token_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+require "walmart_open/auth_token"
+require "timecop"
+
+describe WalmartOpen::AuthToken do
+  let(:auth_token_attrs) do
+    {
+      "token_type"    =>  "bearer",
+      "mapi"          =>  "8tbvkxd6gu6zjzp6qbyeewb6",
+      "access_token"  =>  "k5pzg6jqtetygmrkm5y6qqnr",
+      "expires_in"    =>  600
+    }
+  end
+
+  let(:auth_token) do
+    WalmartOpen::AuthToken.new(auth_token_attrs, Time.now)
+  end
+
+  context ".new" do
+    it "initializes with attributes" do
+      Timecop.freeze(Time.now) do
+        expect(auth_token.expiration_time).to eq(Time.now + auth_token_attrs["expires_in"])
+        expect(auth_token.token_type).to eq(auth_token_attrs["token_type"])
+        expect(auth_token.access_token).to eq(auth_token_attrs["access_token"])
+        expect(auth_token.time).to eq(Time.now)
+      end
+    end
+  end
+
+  context "#expired?" do
+    it "returns true when auth token has expired" do
+      Timecop.freeze(Time.now) do
+        auth_token
+
+        Timecop.freeze(Time.now + auth_token_attrs["expires_in"] + WalmartOpen::AuthToken::BUFFER_TIME) do
+          expect(auth_token).to be_expired
+        end
+      end
+    end
+
+    it "returns false when auth token has not expired" do
+      Timecop.freeze(Time.now) do
+        expect(auth_token).not_to be_expired
+      end
+    end
+  end
+
+  context "#authorization_header" do
+    it "returns authentication_header" do
+      expect(auth_token.authorization_header).to eq("Bearer k5pzg6jqtetygmrkm5y6qqnr")
+    end
+  end
+end

data/spec/walmart_open/client_spec.rb

@@ -0,0 +1,92 @@
+require "spec_helper"
+require "walmart_open/client"
+require "walmart_open/config"
+require "walmart_open/requests/search"
+require "walmart_open/order"
+
+describe WalmartOpen::Client do
+  context ".new" do
+    context "when block is given" do
+      it "yields the config" do
+        yielded_config = nil
+
+        client = WalmartOpen::Client.new do |config|
+          yielded_config = config
+        end
+
+        expect(yielded_config).to be_kind_of(WalmartOpen::Config)
+        expect(yielded_config).to eq(client.config)
+      end
+    end
+
+    context "when block is not given" do
+      it "does not complain" do
+        client = WalmartOpen::Client.new
+      end
+    end
+  end
+
+  context "#search" do
+    it "delegates the request and returns the response" do
+      client = WalmartOpen::Client.new
+      query = double
+      params = double
+      request = double
+
+      expect(WalmartOpen::Requests::Search).to receive(:new) do |query_arg, params_arg|
+        expect(query_arg).to eq(query)
+        expect(params_arg).to eq(params)
+        request
+      end
+      expect(client.connection).to receive(:request).with(request)
+
+      client.search(query, params)
+    end
+  end
+
+  context "#lookup" do
+    it "delegates the request and returns the response" do
+      client = WalmartOpen::Client.new
+      item_id = double
+      params = double
+      request = double
+
+      expect(WalmartOpen::Requests::Lookup).to receive(:new) do |item_id_arg, params_arg|
+        expect(item_id_arg).to eq(item_id)
+        expect(params_arg).to eq(params)
+        request
+      end
+      expect(client.connection).to receive(:request).with(request)
+
+      client.lookup(item_id, params)
+    end
+  end
+
+  context "#taxonomy" do
+    it "delegates the request and returns the response" do
+      client = WalmartOpen::Client.new
+      request = double
+
+      expect(WalmartOpen::Requests::Taxonomy).to receive(:new).and_return(request)
+      expect(client.connection).to receive(:request).with(request)
+
+      client.taxonomy
+    end
+  end
+
+  context "#order" do
+    it "delegates the request and returns the response" do
+      client = WalmartOpen::Client.new
+      request = double
+      order_info = double
+      auth_token = double
+
+      expect(WalmartOpen::Requests::PlaceOrder).to receive(:new).and_return(request)
+      expect(WalmartOpen::Requests::Token).to receive(:new).and_return(auth_token)
+      expect(client.connection).to receive(:request).with(auth_token).and_return(auth_token)
+      expect(client.connection).to receive(:request).with(request)
+
+      client.order(order_info)
+    end
+  end
+end

data/spec/walmart_open/config_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+require "walmart_open/config"
+require "walmart_open/client"
+require "walmart_open/errors"
+
+describe WalmartOpen::Config do
+  context ".new" do
+    it "sets default configs" do
+      config = WalmartOpen::Config.new
+
+      expect(config.debug).to be(false)
+      expect(config.product_domain).to eq("walmartlabs.api.mashery.com")
+      expect(config.product_version).to eq("v1")
+      expect(config.commerce_domain).to eq("api.walmartlabs.com")
+      expect(config.commerce_version).to eq("v1")
+      expect(config.product_calls_per_second).to be(5)
+      expect(config.commerce_calls_per_second).to be(2)
+    end
+
+    it "allows setting configs" do
+      config = WalmartOpen::Config.new({debug: true, product_domain: "test",
+                commerce_domain: "test", product_version: "test",
+                commerce_version: "test", product_calls_per_second: 1,
+                commerce_calls_per_second: 1})
+
+      expect(config.debug).to be(true)
+      expect(config.product_domain).to eq("test")
+      expect(config.product_version).to eq("test")
+      expect(config.commerce_domain).to eq("test")
+      expect(config.commerce_version).to eq("test")
+      expect(config.product_calls_per_second).to be(1)
+      expect(config.commerce_calls_per_second).to be(1)
+    end
+  end
+end

data/spec/walmart_open/connection_manager_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+require "walmart_open/connection_manager"
+require "walmart_open/client"
+require "walmart_open/product_request"
+require "timecop"
+
+describe WalmartOpen::ConnectionManager do
+  context "#request" do
+    let(:client) do
+      WalmartOpen::Client.new(
+        product_calls_per_second: 1,
+        commerce_calls_per_second: 1
+      )
+    end
+
+    let(:connection_manager) { client.connection }
+
+    shared_examples "a request" do
+      it "does not sleep when under calls per second threshold" do
+        expect(request).to receive(:submit).twice
+        expect(connection_manager).not_to receive(:sleep)
+
+        Timecop.freeze(Time.now) do
+          connection_manager.request(request)
+
+          Timecop.freeze(Time.now + 1) do
+            connection_manager.request(request)
+          end
+        end
+      end
+
+      it "sleeps when exceeds calls per second threshold" do
+        expect(request).to receive(:submit).at_least(:once)
+        expect(connection_manager).to receive(:sleep).with(0.5)
+
+        Timecop.freeze(Time.now) do
+          connection_manager.request(request)
+
+          Timecop.freeze(Time.now + 0.5) do
+            connection_manager.request(request)
+          end
+        end
+      end
+    end
+
+    context "when product request" do
+      let(:request) { WalmartOpen::ProductRequest.new }
+
+      include_examples "a request"
+    end
+
+    context "when commerce request" do
+      let(:request) { WalmartOpen::CommerceRequest.new }
+
+      include_examples "a request"
+    end
+  end
+end

data/spec/walmart_open/item_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+require "walmart_open/item"
+
+describe WalmartOpen::Item do
+  let(:item_attrs) do
+    {
+      "itemId"                  =>  10371356,
+      "parentItemId"            =>  10371356,
+      "name"                    =>  "Microplush Blanket",
+      "salePrice"               =>  22.97,
+      "upc"                     =>  "801418711959",
+      "categoryPath"            =>  "Home/Bedding/Blankets & Throws",
+      "shortDescription"        =>  "Cuddle up in bed, on the couch, or even on a sandy beach with this super-soft and thick microfiber blanket. It's luxuriously crafted to provide sumptuous warmth and comfort, even in the coldest environment. Constructed from 100% microfiber, the blanket yarns feel plush and cozy against your skin. This lavish microplush blanket is available in 7 beautiful colors, and can be elegantly matched to any home decor. It works well as an outdoor blanket too — it's perfect for picnics, long car rides, and trips to the ballpark. Plus, this microplush blanket is easy to take care of without hassle, and saves valuable energy over electric blankets. Now you can bundle up and stay warm anywhere, indoors or out. <p>Soft microplush blanket is available in Twin, Full, Queen and King Sizes.</p>", "longDescription"=>"<p><b>Microplush Blanket, 7 Colors:</b></p><ul><li>Super-soft, thick and plush</li><li>100% microfiber blanket yarns are soft and plush to the touch</li><li>Microplush blanket is suitable for all-year use, and can be used indoors or outdoors without hassle</li><li>Luxurious microplush blanket is easy to clean  just machine wash and tumble dry</li><li>Twin: 90" x 66"</li><li>Full: 90" x 80"</li><li>Queen: 90" x 90"</li><li>King: 90" x 102"</li></ul>",
+      "brandName"               =>  "Sun Yin",
+      "thumbnailImage"          =>  "http://i.walmartimages.com/i/p/00/80/14/18/71/0080141871195_Color_Burgundy_SW_100X100.jpg",
+      "mediumImage"             =>  "http://i.walmartimages.com/i/p/00/80/14/18/71/0080141871195_Color_Burgundy_SW_180X180.jpg", "largeImage"=>"http://i.walmartimages.com/i/p/00/80/14/18/71/0080141871195_Color_Burgundy_SW_500X500.jpg",
+      "productTrackingUrl"      =>  "http://linksynergy.walmart.com/fs-bin/click?id=|LSNID|&offerid=223073.7200&type=14&catid=8&subid=0&hid=7200&tmpid=1081&RD_PARM1=http%253A%252F%252Fwww.walmart.com%252Fip%252FMicroplush-Blanket%252F10371356%253Faffilsrc%253Dapi",
+      "ninetySevenCentShipping" =>  false,
+      "standardShipRate"        =>  4.97,
+      "twoThreeDayShippingRate" =>  10.97,
+      "overnightShippingRate"   =>  14.97,
+      "size"                    =>  "Twin",
+      "color"                   =>  "Burgundy",
+      "marketplace"             =>  false,
+      "shipToStore"             =>  true,
+      "freeShipToStore"         =>  true,
+      "modelNumber"             =>  "BKT051166T",
+      "productUrl"              =>  "http://www.walmart.com/ip/Microplush-Blanket/10371356",
+      "customerRating"          =>  "4.446",
+      "numReviews"              =>  621,
+      "customerRatingImage"     =>  "http://i2.walmartimages.com/i/CustRating/4_4.gif",
+      "categoryNode"            =>  "4044_539103_4756",
+      "rollBack"                =>  false,
+      "bundle"                  =>  false,
+      "clearance"               =>  false,
+      "preOrder"                =>  false,
+      "stock"                   =>  "Available",
+      "availableOnline"         =>  true
+    }
+  end
+
+  context ".new" do
+    it "sets attributes" do
+      item = WalmartOpen::Item.new(item_attrs)
+
+      WalmartOpen::Item::API_ATTRIBUTES_MAPPING.each do |key, value|
+        expect(item.send(value)).to eq(item_attrs[key])
+      end
+      expect(item.raw_attributes).to eq(item_attrs)
+    end
+  end
+end

data/spec/walmart_open/order_item_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+require "walmart_open/order_item"
+
+describe WalmartOpen::OrderItem do
+  context ".new" do
+    it "sets value correctly" do
+      item_id = 10371356
+      item_price = 1.23
+      order_item = WalmartOpen::OrderItem.new(item_id, item_price)
+
+      expect(order_item.item_id).to eq(item_id)
+      expect(order_item.item_price).to eq(item_price)
+      expect(order_item.shipping_price).to eq(0)
+      expect(order_item.quantity).to eq(1)
+      expect(order_item).to be_valid
+    end
+  end
+end

data/spec/walmart_open/order_results_spec.rb

@@ -0,0 +1,83 @@
+require "spec_helper"
+require "walmart_open/order_results"
+
+describe WalmartOpen::OrderResults do
+  let(:order_results_1_item_attrs) do
+    {
+      "response" => {
+        "orderId" =>"2677921715556",
+        "partnerOrderId"  =>"43",
+        "items"           =>  {
+            "item" => {
+                "itemId"=>"10371356",
+                "quantity"=>"1",
+                "itemPrice"=>"22.97"
+            }
+        },
+        "total"     =>  "29.95",
+        "itemTotal" =>  "22.97",
+        "shipping"  =>"4.97",
+        "salesTax"  =>"2.01",
+        "surcharge" =>"0.00"
+      }
+    }
+  end
+
+  let(:order_results_2_item_attrs) do
+    {
+      "response"  => {
+        "orderId" => "2677922016720",
+        "partnerOrderId" => "44",
+        "items" => {
+            "item"  => [
+                {
+                    "itemId"    => "20658394",
+                    "quantity"  => "1",
+                    "itemPrice" => "12.99"
+                },
+                {
+                    "itemId"    =>  "10371356",
+                    "quantity"  =>  "1",
+                    "itemPrice" =>  "22.97"
+                }
+            ]
+        },
+        "total"     => "39.11",
+        "itemTotal" => "35.96",
+        "shipping"  => "0",
+        "salesTax"  => "3.15",
+        "surcharge" => "0.00"
+      }
+    }
+  end
+
+  context ".new" do
+    it "sets value correctly with one item" do
+      res = WalmartOpen::OrderResults.new(order_results_1_item_attrs)
+
+      expect(res.order_id).to eq(order_results_1_item_attrs["response"]["orderId"])
+      expect(res.partner_order_id).to eq(order_results_1_item_attrs["response"]["partnerOrderId"])
+      expect(res.total).to eq(order_results_1_item_attrs["response"]["itemTotal"])
+      expect(res.shipping).to eq(order_results_1_item_attrs["response"]["shipping"])
+      expect(res.sales_tax).to eq(order_results_1_item_attrs["response"]["salesTax"])
+      expect(res.surcharge).to eq(order_results_1_item_attrs["response"]["surcharge"])
+      expect(res.raw_attributes).to eq(order_results_1_item_attrs)
+      expect(res.items.count).to eq(1)
+      expect(res).not_to be_error
+    end
+
+    it "sets value correctly with multiple items" do
+      res = WalmartOpen::OrderResults.new(order_results_2_item_attrs)
+
+      expect(res.order_id).to eq(order_results_2_item_attrs["response"]["orderId"])
+      expect(res.partner_order_id).to eq(order_results_2_item_attrs["response"]["partnerOrderId"])
+      expect(res.total).to eq(order_results_2_item_attrs["response"]["itemTotal"])
+      expect(res.shipping).to eq(order_results_2_item_attrs["response"]["shipping"])
+      expect(res.sales_tax).to eq(order_results_2_item_attrs["response"]["salesTax"])
+      expect(res.surcharge).to eq(order_results_2_item_attrs["response"]["surcharge"])
+      expect(res.raw_attributes).to eq(order_results_2_item_attrs)
+      expect(res.items.count).to eq(2)
+      expect(res).not_to be_error
+    end
+  end
+end