seko 0.0.1

data/spec/lib/client_spec.rb

@@ -0,0 +1,364 @@
+require 'spec_helper'
+describe Seko::Client do
+
+  let(:token)        { 'abc123' }
+  let(:options)      { { verbose: true, test_mode: true } }
+  let(:live_options) { { verbose: false, test_mode: false } }
+  let(:client)       { Seko::Client.new(token, options) }
+  let(:live_client)  { Seko::Client.new(token, live_options) }
+
+  describe '#initialize' do
+    it 'sets the @token and @options' do
+      expect(client.token).to eq(token)
+      expect(client.options).to eq(options)
+    end
+  end
+
+  describe '#send_order_request' do
+    before do
+      stub_post("salesorders/v1/websubmit.json").with(query: {token: token}).
+        to_return(body: success_response.to_json, headers: json_headers)
+    end
+
+    let(:response) { client.send_order_request(order_hash) }
+
+    it 'sends an POST request with an order object' do
+      expect(response.success?).to eq(true)
+    end
+  end
+
+  describe '#order_request' do
+    let(:expected_result) { fixture(:order_websubmit).to_json }
+
+    it 'formats the ruby hash response to a json object' do
+      expect(client.order_request(order_hash)).to eq(expected_result)
+    end
+  end
+
+  describe 'inventory methods' do
+    before do
+      stub_get("stock/v1/all.json").with(query: {token: token}).
+        to_return(body: fixture(:stock).to_json, headers: json_headers)
+    end
+
+    let(:response)     { client.get_inventory }
+    let(:upc_array)    { [100014, 100015, 100016] }
+    let(:raw_response) { read_json(:stock) }
+
+    describe '#get_inventory' do
+      before { response }
+
+      it 'sets service and enpoints on the client' do
+        expect(client.service).to eq('stock')
+        expect(client.endpoint).to eq('all')
+      end
+
+      it 'returns a Seko::Response object' do
+        expect(response).to be_a(Seko::Response)
+      end
+    end
+
+    describe '#inventory_request' do
+      it 'makes HTTP request and builds Seko::Response object' do
+        parsed = client.map_results(Seko::Stock.parse(Seko::Response.new(raw_response)))
+        expect(response.parsed).to eq(parsed)
+        expect(JSON.parse(response.raw)).to eq(JSON.parse(raw_response))
+      end
+    end
+
+
+    describe '#upcs' do
+      it 'returns array of upcs' do
+        expect(client.upcs(response.parsed)).to eq(upc_array)
+      end
+    end
+
+    describe '#mapped_inventory' do
+      it 'maps inventory into a collection of simple hashes' do
+        expected_collection = [{ quantity: 0  }, { quantity: 10 }, { quantity: 20 }]
+        expect(client.mapped_inventory(upc_array, response.parsed)).to eq(expected_collection)
+      end
+    end
+
+    describe '#map_results' do
+      it 'normalizes the quantity and upc fields' do
+        expect(response.parsed.map { |x| x["qty"] }).to eq([0, 10, 20])
+        expect(response.parsed.map { |x| x["upc"] }).to eq(upc_array)
+      end
+    end
+
+    describe '#map_keys' do
+      it 'maps verbose keys to simpler keys' do
+        expect(client.send(:map_keys, "FreeQuantity")).to eq('qty')
+        expect(client.send(:map_keys, "ProductCode")).to eq('upc')
+      end
+    end
+
+  end
+
+  describe '#submit_product' do
+    let(:product_hash) { { test: '123' } }
+
+    it 'returns a succesful response' do
+      stub_post("products/v1/submit.json").with(query: {token: token}).
+        to_return(status: 200, body: success_response.to_json, headers: json_headers)
+      expect(Seko::Product).to receive(:format).with(product_hash)
+      response = client.submit_product(product_hash)
+      expect(response.success?).to eq(true)
+    end
+  end
+
+  describe '#submit_receipt' do
+    before do
+      stub_post("receipts/v1/submit.json").with(query: {token: token}).
+        to_return(body: success_response.to_json, headers: json_headers)
+    end
+
+    let(:response) { client.submit_receipt(line_items_array, order_hash[:warehouse]) }
+
+    it 'sends an POST request with a receipt object' do
+      expect(response.success?).to eq(true)
+    end
+  end
+
+  describe '#submit_company' do
+    before do
+      stub_post("companies/v1/submit.json").with(query: {token: token}).
+        to_return(body: success_response.to_json, headers: json_headers)
+    end
+
+    let(:response) { client.submit_company(company_submit_hash) }
+
+    it 'sends an POST request with a company object' do
+      expect(response.success?).to eq(true)
+    end
+  end
+
+  describe '#check_grn' do
+    let(:guid) { '5b2dcd8e-52c3-4e27-a712-eaacda2dd8fe' }
+    let(:response) { client.check_grn(guid) }
+
+    before do
+      stub_get("grns/v1/#{guid}.json").with(query: {token: token}).
+        to_return(body: fixture(:grn).to_json, headers: json_headers)
+    end
+
+    it 'gets a GRN response' do
+      expect(response.success?).to eq(true)
+    end
+
+  end
+
+  describe '#order_status' do
+    let(:guid) { 'f66fd245-7b9e-4fd2-9dbf-5631edc875d9' }
+    let(:response) { client.order_status(guid) }
+
+    before do
+      stub_get("salesorders/v1/#{guid}/status.json").with(query: {token: token}).
+        to_return(body: fixture(:order_status).to_json, headers: json_headers)
+    end
+
+    it "gets an order's status" do
+      expect(response.success?).to eq(true)
+    end
+  end
+
+  describe '#order_tracking' do
+    let(:guid) { 'f66fd245-7b9e-4fd2-9dbf-5631edc875d9' }
+    let(:response) { client.order_tracking(guid) }
+
+    before do
+      stub_get("salesorders/v1/#{guid}/tracking.json").with(query: {token: token}).
+        to_return(body: fixture(:order_tracking).to_json, headers: json_headers)
+    end
+
+    it "gets an order's status" do
+      expect(response.success?).to eq(true)
+    end
+  end
+
+  describe '#cancel_order' do
+    let(:guid) { 'f66fd245-7b9e-4fd2-9dbf-5631edc875d9' }
+    let(:response) { client.cancel_order(guid, '001') }
+
+    before do
+      stub_post("salesorders/v1/#{guid}/cancel/reasoncode/001.json").with(query: {token: token}).
+        to_return(body: success_response.to_json, headers: json_headers)
+    end
+
+    it "gets an order's status" do
+      expect(response.success?).to eq(true)
+    end
+  end
+
+  describe '#stock_adjustments' do
+    let(:from)      { '2013-10-31T00:00:00Z' }
+    let(:to)        { '2014-10-31T00:00:00Z' }
+    let(:warehouse) { 'DC123' }
+    let(:response)  { client.stock_adjustments(Date.parse(from), Date.parse(to), warehouse) }
+
+    before do
+      stub_get("stock/v1/adjustment/#{from}/#{to}.json").with(query: {token: token, dc: warehouse}).
+        to_return(body: fixture(:stock_adjustment).to_json, headers: json_headers)
+    end
+
+    it "gets stock adjustments in timeframe" do
+      expect(response.success?).to eq(true)
+    end
+  end
+
+  describe '#stock_movements' do
+    let(:from)      { '2013-10-31T00:00:00Z' }
+    let(:to)        { '2014-10-31T00:00:00Z' }
+    let(:warehouse) { 'DC123' }
+    let(:response)  { client.stock_movements(Date.parse(from), Date.parse(to), warehouse) }
+
+    before do
+      stub_get("stock/v1/movement/#{from}/#{to}.json").with(query: {token: token, dc: warehouse}).
+        to_return(body: fixture(:stock_movement).to_json, headers: json_headers)
+    end
+
+    it "gets stock movements in timeframe" do
+      expect(response.success?).to eq(true)
+    end
+  end
+
+  describe '#dispatch_statuses' do
+    let(:from)      { '2013-10-31T00:00:00Z' }
+    let(:to)        { '2014-10-31T00:00:00Z' }
+    let(:warehouse) { 'DC123' }
+    let(:response)  { client.dispatch_statuses(Date.parse(from), Date.parse(to), warehouse) }
+
+    before do
+      stub_get("dispatches/v1/status/#{from}/#{to}.json").with(query: {token: token, dc: warehouse, status: 'Dispatched'}).
+        to_return(body: fixture(:dispatch_statuses).to_json, headers: json_headers)
+    end
+
+    it "gets dispatch statuses in timeframe" do
+      expect(response.success?).to eq(true)
+    end
+  end
+
+  describe '#request_uri' do
+    it 'builds the request URI' do
+      expect(client).to receive(:host).and_return('test.com/')
+      expect(client).to receive(:path).and_return('test')
+      expect(client).to receive(:token).and_return('abc123')
+      expect(client.request_uri).to eq("https://test.com/test?token=abc123")
+    end
+  end
+
+  describe '#path' do
+    it 'builds the URI path' do
+      expect(client).to receive(:service).and_return('test')
+      expect(client).to receive(:endpoint).and_return('testendpoint')
+      expect(client.path).to eq("/hub/api/test/v1/testendpoint.json")
+    end
+  end
+
+  describe 'private methods' do
+
+    describe '#default_options' do
+      it 'returns default options' do
+        expect(client.send(:default_options)).to eq({ verbose: false, test_mode: true })
+      end
+    end
+
+    describe '#testing?' do
+      it 'returns a boolean to check test mode' do
+        expect(client.send(:testing?)).to      eq(true)
+        expect(live_client.send(:testing?)).to eq(false)
+      end
+    end
+
+    describe '#verbose?' do
+      it 'returns a boolean to check whether to log results or not' do
+        expect(client.send(:verbose?)).to      eq(true)
+        expect(live_client.send(:verbose?)).to eq(false)
+      end
+    end
+
+    describe '#host' do
+      it 'returns host depending of test mode' do
+        expect(client.send(:host)).to      eq(Seko::Client::TEST_HOST)
+        expect(live_client.send(:host)).to eq(Seko::Client::LIVE_HOST)
+      end
+    end
+
+    describe '#log' do
+      it 'logs messages when verbose mode is set' do
+        expect { client.send(:log, 'test') }.to          output(/test/).to_stdout
+        expect { live_client.send(:log, 'test') }.to_not output(/test/).to_stdout
+      end
+    end
+
+    describe '#http' do
+      it 'returns a Net::HTTP object' do
+        expect(client.send(:http)).to be_a(Net::HTTP)
+      end
+    end
+
+    describe '#build_request' do
+
+      let(:get_request)  { client.send(:build_request, 'Get') }
+      let(:post_request) { client.send(:build_request, 'Post') }
+
+      it 'builds a net/https request' do
+        expect(get_request).to  be_a(Net::HTTP::Get)
+        expect(post_request).to be_a(Net::HTTP::Post)
+        expect(get_request.content_type).to eq(Seko::Client::CONTENT_TYPE)
+      end
+    end
+
+    describe '#request' do
+      it 'sets the ssl and verify mode, sends an http request, and returns a response object' do
+        expect(client.send(:http)).to receive(:request).and_return(fake_response)
+        expect(client.send(:request, 'Get')).to be_a(Seko::Response)
+        expect(client.send(:http).use_ssl?).to be(true)
+        expect(client.send(:http).verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE)
+      end
+    end
+
+    describe '#get' do
+      it 'builds and makes a GET request' do
+        expect(client).to receive(:build_request)
+        expect(client).to receive(:request)
+        client.send(:get)
+      end
+    end
+
+    describe '#post' do
+      it 'builds and makes a POST request' do
+        expect(client).to receive(:request)
+        client.send(:post, { test: true })
+      end
+    end
+
+    describe '#parse_response' do
+      let(:json_response) { {test: true}.to_json }
+
+      it 'logs response' do
+        expect(client).to receive(:log).with(json_response)
+        client.send(:parse_response, json_response)
+      end
+
+      it 'parses response into a Seko::Response object' do
+        expect(client.send(:parse_response, json_response)).to be_a(Seko::Response)
+      end
+    end
+
+    describe '#format_from_to' do
+
+      let(:from)            { '2013-10-31T00:00:00Z' }
+      let(:to)              { '2014-10-31T00:00:00Z' }
+      let(:expected_result) { "#{from}/#{to}" }
+
+      it 'returns a url ready from / to string' do
+        expect(client.send(:format_from_to, Date.parse(from), Date.parse(to))).to eq(expected_result)
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/company_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+describe Seko::Company do
+
+  before do
+    Seko.configure(configuration)
+  end
+
+  describe '.format' do
+    it 'formats a simple company hash into a fully formed JSON ready hash' do
+      expected_result = fixture(:company_submit)
+      expect(Seko::Company.format(company_submit_hash)).to eq(expected_result)
+    end
+  end
+
+  describe '.address' do
+    it 'formats a simple address hash into a fully formed JSON ready hash' do
+      expected_result = fixture(:company_submit)["Request"]["List"]["Address"]
+      expect(Seko::Company.address(company_address_hash)).to eq(expected_result)
+    end
+  end
+
+end

data/spec/lib/dispatch_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+describe Seko::Dispatch do
+
+  describe '.parse_collection' do
+    let(:response) { Seko::Response.new(read_json(:dispatch_statuses)) }
+    let(:guid_array) { [
+      "2b5e52cc-fb6f-4ea4-b8cf-cf64e3a2b8db", 
+      "93e92ca2-725a-46f8-90dd-43a16105f78d", 
+      "143544ec-f396-4155-95c6-bf59898e0830"
+    ] }
+
+    it 'returns the relevant stock info' do
+      expect(Seko::Dispatch.parse(response)).to eq(guid_array)
+    end
+  end
+
+end

data/spec/lib/filter_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+describe Seko::Filter do
+
+  describe '.parse' do
+    let(:unfiltered) { "test | this" }
+    let(:expected)   { "test - this" }
+    it 'removes | characters' do
+      expect(Seko::Filter.parse(unfiltered)).to eq (expected)
+    end
+  end
+
+end

data/spec/lib/order_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+describe Seko::Order do
+
+  let(:email) { "stephen.jones@gmail.com" }
+
+  before do
+    Seko.configure(configuration)
+  end
+
+  describe '.websubmit' do
+    it 'returns a JSON order object for a web order' do
+      expected_result = fixture(:order_websubmit)
+      expect(Seko::Order.websubmit(order_hash)).to eq(expected_result)
+    end
+  end
+
+  describe '.submit' do
+    it 'returns a JSON order object for a retailer' do
+      expected_result = fixture(:order_submit)
+      expect(Seko::Order.submit(company_order_hash)).to eq(expected_result)
+    end
+  end
+
+  describe '.format' do
+
+    it 'returns a Seko ready JSON order object' do
+      expected_result = fixture(:order_websubmit)
+      expect(Seko::Order.format(order_hash, 'Web')).to eq(expected_result)
+    end
+
+  end
+
+  describe '.address' do
+
+    it 'returns JSON format ready address' do
+      expected_result = fixture(:order_websubmit)["Request"]["DeliveryDetails"]
+      expect(Seko::Order.address(address_hash, email)).to eq(expected_result)
+    end
+
+  end
+
+  describe '.line_items' do
+
+    it 'returns JSON format ready line items array' do
+      expected_result = fixture(:order_websubmit)["Request"]["List"]["SalesOrderLineItem"]
+      expect(Seko::Order.line_items(line_items_array)).to eq(expected_result)
+    end
+
+  end
+
+  describe '.company' do
+
+    it 'returns JSON format ready company' do
+      expected_result = { "ShipToCompany" => fixture(:order_submit)["Request"]["ShipToCompany"] }
+      expect(Seko::Order.company(company_hash)).to eq(expected_result)
+    end
+
+  end
+
+end

data/spec/lib/product_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+describe Seko::Product do
+
+  let(:product_hash)  { { upc: 123456, description: "A Test Product" } }
+
+  before do
+    Seko.configure(configuration)
+  end
+
+  describe '.supplier' do
+    it 'reads supplier deatils from config' do
+      expect(Seko.config).to eq(configuration)
+    end
+  end
+
+  describe '.format' do
+    it 'formats a simple product hash into a fully formed JSON ready hash' do
+      expected_result = fixture(:product_submit)
+      expect(Seko::Product.format(product_hash)).to eq(expected_result)
+    end
+  end
+
+end

data/spec/lib/receipt_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+describe Seko::Receipt do
+
+  let(:line_items_array) do
+    [
+      { id: 1, upc: 100083, quantity: 10 },
+      { id: 2, upc: 100076, quantity: 15 }
+    ]
+  end
+
+  before do
+    Seko.configure(configuration)
+  end
+
+  describe '.line_items' do
+    it 'structures line items into JSON ready hash' do
+      expected_result = fixture(:receipt_submit)["Request"]["List"]["ReceiptLineItem"]
+      expect(Seko::Receipt.line_items(line_items_array)).to eq(expected_result)
+    end
+  end
+
+  describe '.format' do
+    it 'formats a fully formed JSON ready hash for receipt' do
+      expected_result = fixture(:receipt_submit)
+      expect(Seko::Receipt).to receive(:random_asn).and_return(123456)
+      expect(Seko::Receipt.format(line_items_array, 'DC123')).to eq(expected_result)
+    end
+  end
+
+  describe '.random_asn' do
+    it 'generates a 10 digit random string' do
+      expect(Seko::Receipt.random_asn).to satisfy { |value| value.size == 10 }
+    end
+  end
+
+end

data/spec/lib/response_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+describe Seko::Response do
+
+  let(:guid)             { 'f66fd245-7b9e-4fd2-9dbf-5631edc875d9' }
+  let(:failed_response)  { "{\n \"CallStatus\": {\n \"Success\": false, \"Message\": \"Failed!\" } }" }
+  let(:errant_raw)       { "{\n \"CallStatus\": {\n \"Success\": true, \"Message\": {} }, \"GUID\": \"#{guid}\" }" }
+  let(:raw_response)     { "{\"Response\": #{errant_raw}}" }
+  let(:parsed_response)  { JSON.parse(raw_response) }
+  let(:response)         { Seko::Response.new(raw_response) }
+  let(:errant_response)  { Seko::Response.new(errant_raw) }
+  let(:failure_response) { Seko::Response.new(failed_response) }
+
+  describe '#initialize' do
+    it 'sets the raw and parsed response' do
+      expect(response.raw).to eq(raw_response)
+      expect(response.parsed).to eq(parsed_response)
+    end
+  end
+
+  describe '#root_response' do
+    it 'fixes an issue in the API were sometimes the "Response" object is present and sometimes it is not' do
+      expect(errant_response.root_response).to eq(response.root_response)
+    end
+  end
+
+  describe '#success?' do
+    it 'checks and returns the proper field in repsonse object for success' do
+      expect(response.success?).to be(true)
+      expect(failure_response.success?).to be(false)
+    end
+  end
+
+  describe '#failure?' do
+    it 'is the opposite of success' do
+      expect(response.failure?).to be(false)
+      expect(failure_response.failure?).to be(true)
+    end
+  end
+
+  describe '#message' do
+    it 'returns the message of the repsonse' do
+      expect(failure_response.message).to eq('Failed!')
+      expect(response.message).to eq('')
+    end
+  end
+
+  describe '#guid' do
+    it 'returns the GUID from the response' do
+      expect(response.guid).to eq(guid)
+    end
+  end
+
+end

data/spec/lib/stock_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+describe Seko::Stock do
+
+  describe '.parse' do
+    it 'returns the relevant stock info' do
+      expected_result = fixture(:stock)["Response"]["List"]["StockQuantityLineItem"]
+      response        = Seko::Response.new(read_json(:stock))
+      expect(Seko::Stock.parse(response)).to eq(expected_result)
+    end
+  end
+
+end