walmart_open 0.0.8 → 0.1.0

data/spec/walmart_open/order_item_spec.rb

@@ -1,43 +0,0 @@
-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
-      item_shipping_price = 2.20
-      order_item = WalmartOpen::OrderItem.new(item_id, 1, item_price, item_shipping_price)
-
-      expect(order_item.item_id).to eq(item_id)
-      expect(order_item.quantity).to eq(1)
-      expect(order_item.item_price).to eq(item_price)
-      expect(order_item.shipping_price).to eq(item_shipping_price)
-      expect(order_item).to be_valid
-    end
-
-    context "#valid?" do
-      context "when required field are present" do
-        it "returns true" do
-          item_id = 10371356
-          order_item = WalmartOpen::OrderItem.new(item_id, 1)
-
-          expect(order_item.item_id).to eq(item_id)
-          expect(order_item.quantity).to eq(1)
-          expect(order_item).to be_valid
-        end
-      end
-
-      context "when required field are not present" do
-        it "returns false" do
-          item_id = nil
-          order_item = WalmartOpen::OrderItem.new(item_id, 1)
-
-          expect(order_item.item_id).to eq(item_id)
-          expect(order_item.quantity).to eq(1)
-          expect(order_item).not_to be_valid
-        end
-      end
-    end
-  end
-end

data/spec/walmart_open/order_results_spec.rb

@@ -1,83 +0,0 @@
-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

data/spec/walmart_open/order_spec.rb

@@ -1,130 +0,0 @@
-require "spec_helper"
-require "walmart_open/order"
-
-describe WalmartOpen::Order do
-  # mix symbol key and string key for testing purpose
-  let(:basic_order_params) do
-    {
-      billing_record_id:       1,
-      partner_order_id:       "42",
-      partner_order_time:     Time.now
-    }
-  end
-
-  let(:shipping_addr_params) do
-    {
-      first_name:   "Testfirstname",
-      last_name:    "Fong",
-      street1:      "Listia Inc, 200 Blossom Ln",
-      street2:      "street2 test",
-      city:         "Mountain View",
-      state:        "CA",
-      zipcode:      "94043",
-      country:      "USA",
-      phone:        "606-478-0850"
-    }
-  end
-
-  let(:required_attrs) do
-    [:billing_record_id, :first_name, :street1, :city, :state, :zipcode, :country, :phone]
-  end
-
-  let(:valid_order_params) { basic_order_params.merge(shipping_addr_params)}
-
-  context "create order" do
-    let(:order) { WalmartOpen::Order.new(valid_order_params) }
-
-    context ".new" do
-      it "sets value correctly" do
-        expect(order.billing_record_id).to eql(valid_order_params[:billing_record_id])
-        expect(order.partner_order_time).to eq(valid_order_params[:partner_order_time])
-        expect(order.partner_order_id).to eq(valid_order_params[:partner_order_id])
-
-        expect(order.shipping_address).to be_valid
-        expect(order.shipping_address.first_name).to eql(valid_order_params[:first_name])
-        expect(order.shipping_address.last_name).to eql(valid_order_params[:last_name])
-        expect(order.shipping_address.phone).to eql(valid_order_params[:phone])
-
-        expect(order.items).to be_empty
-      end
-
-      it "accepts string keys" do
-        stringified_valid_attrs = valid_order_params.each_with_object({}) do |pair, obj|
-          obj[pair.first.to_s] = pair.last
-        end
-        order = WalmartOpen::Order.new(stringified_valid_attrs)
-
-        expect(order.billing_record_id).to eql(valid_order_params[:billing_record_id])
-        expect(order.partner_order_time).to eq(valid_order_params[:partner_order_time])
-        expect(order.partner_order_id).to eq(valid_order_params[:partner_order_id])
-
-        expect(order.shipping_address).to be_valid
-        expect(order.shipping_address.first_name).to eql(valid_order_params[:first_name])
-        expect(order.shipping_address.last_name).to eql(valid_order_params[:last_name])
-        expect(order.shipping_address.phone).to eql(valid_order_params[:phone])
-
-        expect(order.items).to be_empty
-      end
-    end
-
-    context "#add_item" do
-      it "adds item object" do
-        item = double
-        order.add_item(item)
-        expect(order.items).not_to be_empty
-      end
-
-      it "adds item by id" do
-        order.add_item(1)
-        expect(order.items).not_to be_empty
-      end
-    end
-  end
-
-  context "#valid?" do
-    context "when required order params are present" do
-      before do
-        valid_order_params.delete(:last_name)
-        valid_order_params.delete("street2")
-        @order = WalmartOpen::Order.new(valid_order_params)
-        @order.add_item(1)
-      end
-
-      it "returns true" do
-        expect(@order).to be_valid
-      end
-    end
-
-    context "when required order params are not present" do
-      shared_examples_for "missing required key" do |optional_key|
-        before do
-          valid_order_params.delete(optional_key) if optional_key
-        end
-
-        it "returns false" do
-          order = WalmartOpen::Order.new(valid_order_params)
-          order.add_item(item_id) if item_id
-
-          expect(order).not_to be_valid
-        end
-      end
-
-      context "when order item present" do
-        let(:item_id) { 1 }
-        it_behaves_like "missing required key", :billing_record_id
-        it_behaves_like "missing required key", :first_name
-        it_behaves_like "missing required key", :street1
-        it_behaves_like "missing required key", :city
-        it_behaves_like "missing required key", :state
-        it_behaves_like "missing required key", :zipcode
-        it_behaves_like "missing required key", :country
-        it_behaves_like "missing required key", :phone
-      end
-
-      context "when order item not present" do
-        let(:item_id) {nil}
-        it_behaves_like "missing required key", nil
-      end
-    end
-  end
-end

data/spec/walmart_open/requests/place_order_spec.rb

@@ -1,151 +0,0 @@
-require "spec_helper"
-require "walmart_open/requests/place_order"
-require "walmart_open/order"
-require "walmart_open/client"
-require "walmart_open/errors"
-
-describe WalmartOpen::Requests::PlaceOrder do
-  context "#submit" do
-    let(:order_attrs) do
-      {
-        billing_id: 1,
-        first_name: "James",
-        last_name: "Fong",
-        partner_order_id: "44",
-        phone: "606-478-0850"
-      }
-    end
-
-    let(:multiple_order_response) do
-      {
-        "response" => {
-            "orderId" => "2677911169085",
-            "partnerOrderId" => "8",
-            "items" => {
-                "item" => [
-                    {
-                        "itemId" => "25174174",
-                        "quantity" => "1",
-                        "itemPrice" => "214.99"
-                    },
-                    {
-                        "itemId" => "10371356",
-                        "quantity" => "1",
-                        "itemPrice" => "22.97"
-                    }
-                ]
-            },
-            "total" => "259.38",
-            "itemTotal" => "237.96",
-            "shipping" => "0",
-            "salesTax" => "21.42",
-            "surcharge" => "0.00"
-        }
-      }
-    end
-
-    let(:single_order_response) do
-      {
-        "response" => {
-            "orderId" =>  "2677913310915",
-            "partnerOrderId" => "20",
-            "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(:client) { WalmartOpen::Client.new }
-    let(:order) { WalmartOpen::Order.new(order_attrs) }
-    let(:order_req) { WalmartOpen::Requests::PlaceOrder.new(order) }
-    let(:success_response) { double(success?: true) }
-    let(:fail_response) { double(success?: false) }
-
-    before do
-      allow(order_req).to receive(:request_options).and_return({})
-    end
-
-    context "when response is success" do
-      before do
-        allow(HTTParty).to receive(:post).and_return(success_response)
-        allow(success_response).to receive(:code).and_return(200)
-      end
-
-      context "when multiple orders" do
-        before do
-          allow(success_response).to receive(:parsed_response).and_return(multiple_order_response)
-        end
-
-        it "return response" do
-          order = order_req.submit(client)
-          expect(order.raw_attributes).to eq(multiple_order_response)
-        end
-      end
-
-      context "when one order" do
-        before do
-          allow(success_response).to receive(:parsed_response).and_return(single_order_response)
-        end
-
-        it "return response" do
-          order = order_req.submit(client)
-          expect(order.raw_attributes).to eq(single_order_response)
-        end
-      end
-    end
-
-    context "when response is not success" do
-      before do
-        allow(HTTParty).to receive(:post).and_return(fail_response)
-      end
-
-      context "response has http code 400" do
-        before do
-          allow(fail_response).to receive(:code).and_return(400)
-          allow(fail_response).to receive(:parsed_response).and_return({
-            "errors" => {
-                "error" => {
-                    "code" => "10020",
-                    "message" => "This order has already been executed"
-                }
-            }
-          })
-        end
-
-        it "raises order error" do
-          expect{
-            order_req.submit(client)
-          }.to raise_error(WalmartOpen::OrderError)
-        end
-      end
-
-      context "response has http code not 400" do
-        before do
-          allow(fail_response).to receive(:code).and_return(403)
-          allow(fail_response).to receive(:parsed_response).and_return({
-            "errors" => [{
-            "code" => 403,
-            "message" => "Account Inactive"
-            }]
-          })
-        end
-
-        it "raises authentication error" do
-          expect {
-            order_req.submit(client)
-          }.to raise_error(WalmartOpen::ServerError)
-        end
-      end
-    end
-  end
-end

data/spec/walmart_open/requests/token_spec.rb

@@ -1,49 +0,0 @@
-require "spec_helper"
-require "walmart_open/requests/token"
-require "walmart_open/client"
-require "walmart_open/errors"
-
-describe WalmartOpen::Requests::Token do
-  context "#submit" do
-    let(:client) {WalmartOpen::Client.new}
-    let(:token_req) { WalmartOpen::Requests::Token.new }
-    let(:success_response) { double(success?: true) }
-    let(:fail_response) { double(success?: false) }
-
-    context "when response is success" do
-      before do
-        allow(HTTParty).to receive(:post).and_return(success_response)
-        attrs = {
-          "token_type" => "bearer",
-          "mapi" => "8tbvkxd6gu6zjzp6qbyeewb6",
-          "access_token" => "k5pzg6jqtetygmrkm5y6qqnr",
-          "expires_in" => 600
-        }
-        allow(success_response).to receive(:parsed_response).and_return(attrs)
-        header_attrs = {"date"=> "Sun, 01 Dec 2013 07:25:35 GMT"}
-        allow(success_response).to receive(:headers).and_return(header_attrs)
-      end
-
-      it "get response" do
-        token = token_req.submit(client)
-
-        expect(token.token_type).to eq("bearer")
-        expect(token.access_token).to eq("k5pzg6jqtetygmrkm5y6qqnr")
-        expect(token.time).to eq(Time.parse("Sun, 01 Dec 2013 07:25:35 GMT"))
-      end
-    end
-
-    context "when response is not success" do
-      before do
-        allow(HTTParty).to receive(:post).and_return(fail_response)
-        allow(fail_response).to receive(:parsed_response).and_return({"errors"=>[{"code"=>403, "message"=>"Account Inactive"}]})
-      end
-
-      it "get authentication error" do
-        expect{
-          token_req.submit(client)
-        }.to raise_error(WalmartOpen::ServerError)
-      end
-    end
-  end
-end