pixi_client 0.0.5

data/spec/lib/pixi_client/requests/shipping_get_picklist_details_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe PixiClient::Requests::ShippingGetPicklistDetails do
+  let(:picklist_key) { 1 }
+  subject { PixiClient::Requests::ShippingGetPicklistDetails.new(picklist_key) }
+
+  before do
+    set_default_config
+  end
+
+  it { is_expected.to be_a_kind_of(PixiClient::Requests::Base) }
+
+  describe '#api_method' do
+    it 'should return :pixi_add_order_comment' do
+      expect(subject.api_method).to eq :pixi_shipping_get_picklist_details
+    end
+  end
+
+  describe 'call behaviour' do
+    let(:expected_response) { double(body: { pixi_shipping_get_picklist_details_response: { pixi_shipping_get_picklist_details_result: sql_row_set_response_mock } }) }
+    let(:double_client) { double }
+
+    before do
+      allow(subject).to receive(:client).and_return(double_client)
+    end
+
+    it 'should call the client with the appropriate parameters' do
+      expect(double_client).to receive(:call)
+      .with(:pixi_shipping_get_picklist_details, attributes: { xmlns: PixiClient.configuration.endpoint }, message: { 'PicklistKey' => picklist_key })
+      .and_return(expected_response)
+
+      subject.call
+    end
+
+    it 'should instanciate an instance of Response with the response body' do
+      expect(double_client).to receive(:call).and_return(expected_response)
+      expect(PixiClient::Response).to receive(:new).with(:pixi_shipping_get_picklist_details, expected_response.body)
+      subject.call
+    end
+
+    it 'should return an instance of Response' do
+      expect(double_client).to receive(:call).and_return(expected_response)
+      expect(subject.call).to be_an_instance_of(PixiClient::Response)
+    end
+  end
+
+end

data/spec/lib/pixi_client/requests/shipping_get_picklist_headers_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe PixiClient::Requests::ShippingGetPicklistHeaders do
+  let(:location) { '001' }
+  subject { PixiClient::Requests::ShippingGetPicklistHeaders.new(location) }
+
+  before do
+    set_default_config
+  end
+
+  it { is_expected.to be_a_kind_of(PixiClient::Requests::Base) }
+
+  describe '#api_method' do
+    it 'should return :pixi_add_order_comment' do
+      expect(subject.api_method).to eq :pixi_shipping_get_picklist_headers
+    end
+  end
+
+  describe 'call behaviour' do
+    let(:expected_response) { double(body: { pixi_shipping_get_picklist_headers_response: { pixi_shipping_get_picklist_headers_result: sql_row_set_response_mock } }) }
+    let(:double_client) { double }
+
+    before do
+      allow(subject).to receive(:client).and_return(double_client)
+    end
+
+    it 'should call the client with the appropriate parameters' do
+      expect(double_client).to receive(:call)
+      .with(:pixi_shipping_get_picklist_headers, attributes: { xmlns: PixiClient.configuration.endpoint }, message: { 'LocID' => location })
+      .and_return(expected_response)
+
+      subject.call
+    end
+
+    it 'should instanciate an instance of Response with the response body' do
+      expect(double_client).to receive(:call).and_return(expected_response)
+      expect(PixiClient::Response).to receive(:new).with(:pixi_shipping_get_picklist_headers, expected_response.body)
+      subject.call
+    end
+
+    it 'should return an instance of Response' do
+      expect(double_client).to receive(:call).and_return(expected_response)
+      expect(subject.call).to be_an_instance_of(PixiClient::Response)
+    end
+  end
+
+end

data/spec/lib/pixi_client/response_parser_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe PixiClient::ResponseParser do
+  let(:ts) { Time.at(Time.now.to_i) } # HACK: avoid microseconds strange behaviour
+  let(:response_body) { sql_row_set_response_mock(ts) }
+
+  describe 'parsing' do
+    subject(:parser) { PixiClient::ResponseParser.new(response_body) }
+
+    it { is_expected.to be_an_instance_of(PixiClient::ResponseParser) }
+
+    # examples modeled according to our mock (see spec/support/test_helpers)
+
+    describe 'rows building' do
+      before { parser.parse! }
+
+      let(:first_row) { parser.rows.first }
+      let(:second_row) { parser.rows.last }
+
+      it 'should create two rows' do
+        expect(parser.rows.length).to eq 2
+      end
+
+      it 'should set and convert integer attributes' do
+        expect(first_row.int_attr).to eq 1
+        expect(second_row.int_attr).to eq 2
+      end
+
+      it 'should set and convert datetime attributes' do
+        expect(first_row.datetime).to eq ts
+        expect(second_row.datetime).to eq ts
+      end
+
+      it 'should set and convert boolean attributes' do
+        expect(first_row.boolean).to eq true
+        expect(second_row.boolean).to eq false
+      end
+
+      it 'should set and convert string attributes' do
+        expect(first_row.string_attr).to eq 'string1'
+        expect(second_row.string_attr).to eq 'string2'
+      end
+
+      it 'should be able to process attributes with restriction description' do
+        expect(first_row.string_attr_with_restriction).to eq 'restricted_string_1'
+        expect(second_row.string_attr_with_restriction).to eq 'restricted_string_2'
+      end
+    end
+
+    describe 'sql messages building' do
+      before { parser.parse! }
+
+      context 'only one message' do
+        it 'should create an array of one message' do
+          expect(parser.sql_messages.length).to eq 1
+        end
+
+        describe 'messages attributes building' do
+          let(:sql_message) { parser.sql_messages.first }
+
+          it 'should set the message class' do
+            expect(sql_message.message_class).to eq '0'
+          end
+
+          it 'should set the message line number' do
+            expect(sql_message.line_number).to eq '103'
+          end
+
+          it 'should set the message text' do
+            expect(sql_message.message).to eq 'Warning: Null value is eliminated by an aggregate or other SET operation.'
+          end
+
+          it 'sholud set the message number' do
+            expect(sql_message.number).to eq '8153'
+          end
+
+          it 'should set the procedure' do
+            expect(sql_message.procedure).to eq 'pipiGetChangedItemStock'
+          end
+
+          it 'should set the message server' do
+            expect(sql_message.server).to eq 'RGPSQL4'
+          end
+
+          it 'should set the message source' do
+            expect(sql_message.source).to eq 'Microsoft-SQL/10.0'
+          end
+
+          it 'should set the message state' do
+            expect(sql_message.state).to eq '1'
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/pixi_client/soap_request_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe PixiClient::Requests::Base do
+  let(:savon_client) { double('savon_client') }
+  subject { PixiClient::Requests::Base.new }
+
+  before do
+    allow(subject).to receive(:api_method).and_return(:fancy_soap_call)
+    allow(subject).to receive(:message).and_return({ a: 1 })
+    allow(subject).to receive(:client).and_return(savon_client)
+  end
+
+  describe '#call' do
+    it 'should call the savon client with the corresponding params' do
+      expect(savon_client).to(
+        receive(:call).
+          with(subject.api_method, attributes: { xmlns: PixiClient.configuration.endpoint }, message: subject.message).
+          and_return(OpenStruct.new(body: {}))
+      )
+      allow(PixiClient::Response).to receive(:new)
+      subject.call
+    end
+
+    it 'instantiates a PixiClient::Response instance' do
+      allow(savon_client).to receive(:call).and_return(OpenStruct.new(body: {}))
+      expect(PixiClient::Response).to receive(:new).with(subject.api_method, {})
+      response = subject.call
+    end
+  end
+end

data/spec/lib/pixi_client_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe PixiClient do
+  before do
+    PixiClient.configure do |configuration|
+      configuration.endpoint = 'endpoint'
+      configuration.username = 'username'
+      configuration.password = 'random-password'
+    end
+  end
+
+  describe '::configuration' do
+    it 'returns the configuration' do
+      expect(PixiClient.configuration.endpoint).to eq 'endpoint'
+      expect(PixiClient.configuration.username).to eq 'username'
+      expect(PixiClient.configuration.password).to eq 'random-password'
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'pry'
+require 'pixi_client'
+
+Dir[('./spec/support/**/*.rb')].each {|f| require f}
+
+require File.join('lib', 'pixi_client', 'requests', 'itemable_shared_examples')
+
+RSpec.configure do |config|
+  config.filter_run_excluding skip: true
+  config.include TestHelpers
+end

data/spec/support/test_helpers.rb

@@ -0,0 +1,136 @@
+require 'yaml'
+
+module TestHelpers
+  def set_default_config
+    config_data = YAML.load_file(File.join(File.dirname(__FILE__), '../..', 'config', 'pixi.yml'))['test']
+
+    PixiClient.configure do |config|
+      config.endpoint = config_data['endpoint']
+      config.username = config_data['username']
+      config.password = config_data['password']
+    end
+  end
+
+  def set_stock_multiple_parameter_xml_mock
+    <<-EOS
+      <ITEMSTOCK>
+        <ITEM>
+          <EANUPC>12345</EANUPC>
+          <INVBINS>
+            <INVBIN>
+              <BINNAME>A</BINNAME>
+              <STOCK>5</STOCK>
+            </INVBIN>
+          </INVBINS>
+        </ITEM>
+      </ITEMSTOCK>
+    EOS
+  end
+
+  def sql_row_set_response_mock(ts = Time.now)
+    { :sql_message =>
+        {
+          :class => "0",
+          :line_number => "103",
+          :message => "Warning: Null value is eliminated by an aggregate or other SET operation.",
+          :number => "8153",
+          :procedure => "pipiGetChangedItemStock",
+          :server => "RGPSQL4",
+          :source => "Microsoft-SQL/10.0",
+          :state => "1",
+          :"@xsi:type" => "sqlmessage:SqlMessage"
+        },
+      :sql_row_set => {
+        :schema => [
+          {
+            :simple_type => [
+              {
+                :restriction => { :@base => "xsd:int" },
+                :@name => "int"
+              },
+              {
+                :restriction => { :@base => "xsd:string" },
+                :@name => "varchar"
+              },
+              {
+                :restriction => {
+                  :pattern => { :@value => "((000[1-9])|(00[1-9][0-9])|(0[1-9][0-9]{2})|([1-9][0-9]{3}))-((0[1-9])|(1[012]))-((0[1-9])|([12][0-9])|(3[01]))T(([01][0-9])|(2[0-3]))(:[0-5][0-9]){2}(\\.[0-9]{2}[037])?" },
+                  :min_inclusive => { :@value => "1753-01-01T00:00:00.000" },
+                  :max_inclusive => { :@value=>"9999-12-31T23:59:59.997" },
+                  :@base => "xsd:dateTime"
+                },
+                :@name => "datetime"
+              },
+              {
+                :restriction => { :@base => "xsd:boolean" },
+                :@name => "bit"
+              }
+            ],
+            :"@xmlns:xsd" => "http://www.w3.org/2001/XMLSchema",
+            :@target_namespace => "http://schemas.microsoft.com/sqlserver/2004/sqltypes"
+          },
+          {
+            :import => { :@namespace => "http://schemas.microsoft.com/sqlserver/2004/sqltypes" },
+            :element => {
+              :complex_type => {
+                :sequence => {
+                  :element => {
+                    :complex_type => {
+                      :sequence => {
+                        :element => [
+                          { :@name => "int_attr", :@type => "sqltypes:int" },
+                          { :@name => "DATETIME", :@type => "sqltypes:datetime", :@min_occurs => "0"},
+                          { :@name => "boolean", :@type => "sqltypes:bit", :@min_occurs => "0"},
+                          { :@name => "StringAttr", :@type => "sqltypes:varchar"},
+                          {
+                            :simple_type => {
+                              :restriction => {
+                                :max_length => { :@value => "13" },
+                                :@base => "sqltypes:varchar",
+                                :"@sqltypes:locale_id" => "1033",
+                                :"@sqltypes:sql_compare_options" => "IgnoreCase IgnoreKanaType IgnoreWidth"
+                              }
+                            },
+                            :@name => "StringAttrWithRestriction",
+                            :@min_occurs=>"0"
+                          },
+                        ]
+                      }
+                    },
+                    :@name => "row",
+                    :@min_occurs => "0",
+                    :@max_occurs => "unbounded"
+                  }
+                }
+              },
+              :@name => "SqlRowSet1",
+              :"@msdata:is_data_set" => "true",
+              :"@msdata:data_set_namespace" => "urn:schemas-microsoft-com:sql:SqlDataSet",
+              :"@msdata:data_set_name" => "SqlDataSet"
+            },
+            :@xmlns=>"",
+            :"@xmlns:xsd" => "http://www.w3.org/2001/XMLSchema",
+            :"@xmlns:sqltypes" => "http://schemas.microsoft.com/sqlserver/2004/sqltypes",
+            :@target_namespace => "urn:schemas-microsoft-com:sql:SqlRowSet1",
+            :@element_form_default => "qualified"
+          }
+        ],
+        :diffgram => {
+          :sql_row_set1 => {
+            :row => [
+              { :int_attr => '1', :datetime => ts, :boolean => '1', :string_attr => 'string1', :string_attr_with_restriction => 'restricted_string_1' },
+              { :int_attr => '2', :datetime => ts, :boolean => '0', :string_attr => 'string2', :string_attr_with_restriction => 'restricted_string_2' }
+            ],
+            :@xmlns => "urn:schemas-microsoft-com:sql:SqlRowSet1"
+          },
+          :"@xmlns:diffgr" => "urn:schemas-microsoft-com:xml-diffgram-v1"
+        },
+        :"@xsi:type" => "sqlsoaptypes:SqlRowSet",
+        :"@msdata:use_data_set_schema_only" => "true",
+        :"@msdata:udt_column_value_wrapped" => "true"
+      },
+      :sql_result_code => "0",
+      :@xmlns => ""
+    }
+  end
+end