fishbowl 0.0.1 → 0.0.2

data/spec/objects/account_spec.rb

@@ -14,6 +14,21 @@ describe Fishbowl::Objects::Account do
 
   let(:connection) { FakeTCPSocket.instance }
 
+  describe "instances" do
+
+    let(:account) {
+      doc = Nokogiri::XML.parse(example_file('account.xml'))
+      Fishbowl::Objects::Account.new(doc.xpath('//Account'))
+    }
+
+    it "should properly initialize from example file" do
+      account.name.should eq("Cost Variance")
+      account.accounting_id.should eq("8000001B-1310422643")
+      account.account_type.should eq("12")
+      account.balance.should eq("0")
+    end
+  end
+
   describe ".get_list" do
     let(:proper_request) do
       Nokogiri::XML::Builder.new do |xml|
@@ -26,8 +41,23 @@ describe Fishbowl::Objects::Account do
       end
     end
 
-    let(:canned_response) do
+    before :each do
+      canned_response = Nokogiri::XML::Builder.new do |xml|
+        xml.response {
+          xml.GetAccountListRs(statusCode: '1000', statusMessage: "Success!") {
+            (rand(3) + 2).times do |i|
+              xml.Account {
+                xml.Name          "Demo Account #{i}"
+                xml.AccountingID  "DEMO#{i}"
+                xml.AccountType   i
+                xml.Balance       "1200.00"
+              }
+            end
+          }
+        }
+      end
 
+      mock_the_response(canned_response)
     end
 
     it "should properly format the request" do
@@ -35,10 +65,8 @@ describe Fishbowl::Objects::Account do
       connection.last_write.should be_equivalent_to(proper_request.to_xml)
     end
 
-    it "should return array of Accounts"
-
-    it "should return empty array when no accounts" do
-
+    it "should return array of Accounts" do
+      Fishbowl::Objects::Account.get_list.should be_an(Array)
     end
   end
 
@@ -56,11 +84,30 @@ describe Fishbowl::Objects::Account do
       end
     end
 
+    before :each do
+      canned_response = Nokogiri::XML::Builder.new do |xml|
+        xml.response {
+          xml.GetAccountBalanceRs(statusCode: '1000', statusMessage: "Success!") {
+            xml.Account {
+              xml.Name          "Demo Account"
+              xml.AccountingID  "DEMO"
+              xml.AccountType   9
+              xml.Balance       "1200.00"
+            }
+          }
+        }
+      end
+
+      mock_the_response(canned_response)
+    end
+
     it "should properly format the request" do
       Fishbowl::Objects::Account.get_balance("General Account")
       connection.last_write.should be_equivalent_to(proper_request.to_xml)
     end
 
-    it "should return the balance for the requested Account"
+    it "should return the balance for the requested Account" do
+      Fishbowl::Objects::Account.get_balance("General Account").should be_a(String)
+    end
   end
 end

data/spec/objects/address_information_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Fishbowl::Objects::AddressInformation do
+  describe "instances" do
+
+    let(:address_info) {
+      doc = Nokogiri::XML.parse(example_file('address.xml'))
+      Fishbowl::Objects::AddressInformation.new(doc.xpath('//AddressInformation'))
+    }
+
+    it "should properly initialize from example file" do
+      address_info.name.should eq("Main Office")
+      address_info.data.should eq("Address Data")
+      address_info.default.should eq("true")
+      address_info.type.should eq("Home")
+    end
+  end
+end

data/spec/objects/address_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Fishbowl::Objects::Address do
+  before :each do
+    mock_tcp_connection
+    mock_login_response
+    Fishbowl::Connection.connect(host: 'localhost')
+    Fishbowl::Connection.login(username: 'johndoe', password: 'secret')
+  end
+
+  after :each do
+    unmock_tcp
+  end
+
+  let(:connection) { FakeTCPSocket.instance }
+
+  describe "instances" do
+
+    let(:address) {
+      doc = Nokogiri::XML.parse(example_file('address.xml'))
+      Fishbowl::Objects::Address.new(doc.xpath('//Address'))
+    }
+
+    it "should properly initialize from example file" do
+      address.name.should eq("Main Office")
+      address.attn.should eq("Attn")
+      address.street.should eq("123 Neverland dr.")
+
+      address.state.should be_a(Fishbowl::Objects::State)
+      address.country.should be_a(Fishbowl::Objects::Country)
+      address.address_information_list.should be_a(Array)
+      address.address_information_list.first.should be_a(Fishbowl::Objects::AddressInformation)
+    end
+  end
+end
+

data/spec/objects/base_object_spec.rb

@@ -3,6 +3,7 @@ require 'spec_helper'
 describe Fishbowl::Objects::BaseObject do
   let(:ticket) { "thisisasample" }
   let(:base_object) { Fishbowl::Objects::BaseObject.new }
+  let(:connection) { FakeTCPSocket.instance }
 
   let(:empty_ticket_builder) do
     Nokogiri::XML::Builder.new do |xml|
@@ -10,7 +11,7 @@ describe Fishbowl::Objects::BaseObject do
         xml.Ticket
 
         xml.FbiMsgsRq {
-          xml.SampleRequest
+          xml.SampleRq
         }
       }
     end
@@ -22,43 +23,86 @@ describe Fishbowl::Objects::BaseObject do
         xml.Ticket ticket
 
         xml.FbiMsgsRq {
-          xml.SampleRequest
+          xml.SampleRq
         }
       }
     end
   end
 
-  context "Protected Methods" do
-    describe "#send_request" do
+  before :each do
+    mock_tcp_connection
+    mock_login_response
+    Fishbowl::Connection.connect(host: 'localhost')
+    Fishbowl::Connection.login(username: 'johndoe', password: 'secret')
+  end
 
-    end
+  after :each do
+    unmock_tcp
   end
 
-  context "Private Methods" do
-    describe "#build_request" do
-      it "should build a request document" do
-        base_object.send(:build_request, "SampleRequest").to_xml.should be_equivalent_to(empty_ticket_builder.to_xml)
-      end
+  describe "#send_request" do
+    before :each do
+      mock_the_response
+    end
 
-      it "should accept an XML Builder" do
-        builder = Nokogiri::XML::Builder.new { |xml| xml.request { xml.SampleRequest } }
-        base_object.send(:build_request, builder, true).to_xml.should be_equivalent_to(empty_ticket_builder.to_xml)
-      end
+    it "should include the ticket value when it's set" do
+      base_object.ticket = ticket
+      base_object.send_request("SampleRq", "SampleRs")
+      connection.last_write.should be_equivalent_to(ticket_builder.to_xml)
+    end
 
-      context "when ticket is empty" do
-        it "should return an empty Nokogiri::XML::Builder" do
-          base_object.send(:build_request, "SampleRequest").to_xml.should be_equivalent_to(empty_ticket_builder.to_xml)
-        end
+    it "should send the specified request" do
+      base_object.send_request("SampleRq", "SampleRs")
+      connection.last_write.should be_equivalent_to(empty_ticket_builder.to_xml)
+    end
+
+    it "should get the expected response" do
+      code, message, response = base_object.send_request("SampleRq", "SampleRs")
+
+      code.should_not be_nil
+      message.should_not be_nil
+      response.should be_equivalent_to(mock_response.to_xml)
+    end
+  end
+
+  context "Protected Methods" do
+    describe ".attributes" do
+      it "should return an array containing 'ID' by default" do
+        Fishbowl::Objects::BaseObject.attributes.should eq(["ID"])
       end
+    end
 
-      context "when ticket is set" do
-        before :each do
-          base_object.ticket = ticket
+    describe "#parse_attributes" do
+      it "should parse the requested attributes from the supplied xml" do
+        parse_xml = Nokogiri::XML::Builder.new do |xml|
+          xml.parse {
+            xml.ID "5"
+            xml.DataID "15"
+            xml.Name "Demo"
+            xml.SKU "DEMO"
+          }
         end
+        parse_xml = Nokogiri::XML.parse(parse_xml.to_xml)
 
-        it "should return the ticket wrapped in a Nokogiri::XML::Builder" do
-          base_object.send(:build_request, "SampleRequest").to_xml.should be_equivalent_to(ticket_builder.to_xml)
+        class Fishbowl::Objects::BaseObject
+          def self.attributes
+            %w{ID DataID Name SKU}
+          end
         end
+
+        base_object.instance_variable_set("@xml", parse_xml.xpath('parse'))
+
+        base_object.send(:parse_attributes)
+
+        base_object.instance_variables.should include(:@db_id)
+        base_object.instance_variables.should include(:@data_id)
+        base_object.instance_variables.should include(:@name)
+        base_object.instance_variables.should include(:@sku)
+
+        base_object.instance_variable_get(:@db_id).should eq("5")
+        base_object.instance_variable_get(:@data_id).should eq("15")
+        base_object.instance_variable_get(:@name).should eq("Demo")
+        base_object.instance_variable_get(:@sku).should eq("DEMO")
       end
     end
   end

data/spec/objects/carrier_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Fishbowl::Objects::Carrier do
+  describe "instances" do
+
+    let(:carrier) {
+      doc = Nokogiri::XML.parse(example_file('carrier.xml'))
+      Fishbowl::Objects::Carrier.new(doc.xpath('//Carrier'))
+    }
+
+    it "should properly initialize from example file" do
+      carrier.name.should eq("Will Call")
+    end
+  end
+end

data/spec/objects/carton_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Fishbowl::Objects::Carton do
+  describe "instances" do
+
+    let(:carton) {
+      doc = Nokogiri::XML.parse(example_file('carton.xml'))
+      Fishbowl::Objects::Carton.new(doc.xpath('//Carton'))
+    }
+
+    it "should properly initialize from example file" do
+      carton.db_id.should eq("64")
+      carton.ship_id.should eq("63")
+      carton.carton_num.should eq("1")
+      carton.tracking_num.should be_empty
+      carton.freight_weight.should eq("1.2")
+      carton.freight_amount.should eq("0")
+
+      carton.shipping_items.first.should be_a(Fishbowl::Objects::ShippingItem)
+    end
+  end
+end
+

data/spec/objects/country_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Fishbowl::Objects::Country do
+  describe "instances" do
+
+    let(:country) {
+      doc = Nokogiri::XML.parse(example_file('address.xml'))
+      Fishbowl::Objects::Country.new(doc.xpath('//Country'))
+    }
+
+    it "should properly initialize from example file" do
+      country.name.should eq("United States")
+      country.code.should eq("US")
+    end
+  end
+end

data/spec/objects/shipping_item_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Fishbowl::Objects::Carton do
+  describe "instances" do
+
+    let(:shipping_item) {
+      doc = Nokogiri::XML.parse(example_file('carton.xml'))
+      Fishbowl::Objects::ShippingItem.new(doc.xpath('//ShippingItem'))
+    }
+
+    it "should properly initialize from example file" do
+      shipping_item.ship_item_id.should eq("169")
+      shipping_item.product_number.should eq("B201")
+
+      shipping_item.uom.should be_a(Fishbowl::Objects::UOM)
+      shipping_item.weight_uom.should be_a(Fishbowl::Objects::UOM)
+      shipping_item.display_weight_uom.should be_a(Fishbowl::Objects::UOM)
+    end
+  end
+end
+

data/spec/objects/state_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Fishbowl::Objects::State do
+  describe "instances" do
+
+    let(:state) {
+      doc = Nokogiri::XML.parse(example_file('address.xml'))
+      Fishbowl::Objects::State.new(doc.xpath('//State'))
+    }
+
+    it "should properly initialize from example file" do
+      state.name.should eq("Utah")
+      state.code.should eq("UT")
+      state.country_id.should eq("2")
+    end
+  end
+end

data/spec/objects/uom_conversion_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Fishbowl::Objects::UOMConversion do
+  describe "instances" do
+
+    let(:uom_conversion) {
+      doc = Nokogiri::XML.parse(example_file('uom_conversion.xml'))
+      Fishbowl::Objects::UOMConversion.new(doc.xpath('//UOMConversion'))
+    }
+
+    it "should properly initialize from example file" do
+      uom_conversion.main_uom_id.should eq("1")
+      uom_conversion.to_uom_id.should eq("17")
+      uom_conversion.to_uom_code.should eq("pr")
+      uom_conversion.conversion_multiply.should eq("1.0")
+      uom_conversion.conversion_factor.should eq("2.0")
+      uom_conversion.to_uom_is_integral.should eq("false")
+    end
+  end
+end

data/spec/objects/uom_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Fishbowl::Objects::UOM do
+  describe "instances" do
+
+    let(:uom) {
+      doc = Nokogiri::XML.parse(example_file('uom.xml'))
+      Fishbowl::Objects::UOM.new(doc.xpath('//UOM'))
+    }
+
+    it "should properly initialize from example file" do
+      uom.uomid.should eq("1")
+      uom.name.should eq("Each")
+      uom.code.should eq("ea")
+
+      uom.uom_conversions.should be_a(Array)
+      uom.uom_conversions.first.should be_a(Fishbowl::Objects::UOMConversion)
+    end
+  end
+end

data/spec/objects/user_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Fishbowl::Objects::User do
+  describe "instances" do
+
+    let(:user) {
+      doc = Nokogiri::XML.parse(example_file('user.xml'))
+      Fishbowl::Objects::User.new(doc.xpath('//User'))
+    }
+
+    it "should properly initialize from example file" do
+      user.db_id.should eq("1")
+      user.user_name.should eq("admin")
+      user.first_name.should eq("Administrator")
+      user.last_name.should eq("Administrator")
+      user.initials.should eq("ADM")
+      user.active.should eq("true")
+    end
+  end
+end

data/spec/requests/add_inventory_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Fishbowl::Requests do
+  describe "#add_inventory" do
+    before :each do
+      mock_tcp_connection
+      mock_login_response
+      Fishbowl::Connection.connect(host: 'localhost')
+      Fishbowl::Connection.login(username: 'johndoe', password: 'secret')
+    end
+
+    let(:connection) { FakeTCPSocket.instance }
+
+    let(:valid_options) {
+      {
+        part_number:          "B103",
+        quantity:             6,
+        uom_id:               1,
+        cost:                 33.01,
+        location_tag_number:  1,
+        tag_number:           1
+      }
+    }
+
+    it "requires valid options" do
+      lambda {
+        Fishbowl::Requests.add_inventory(valid_options)
+      }.should_not raise_error(ArgumentError)
+
+      valid_options.each do |excluded_key, excluded_value|
+        invalid_options = valid_options.keep_if {|k,v| k != excluded_key}
+
+        lambda {
+          Fishbowl::Requests.add_inventory(invalid_options)
+        }.should raise_error(ArgumentError)
+      end
+    end
+
+    it "sends proper request" do
+      mock_the_response('AddInventoryRs')
+      Fishbowl::Requests.add_inventory(valid_options)
+      connection.last_write.should be_equivalent_to(expected_request)
+    end
+
+    it "includes note option when supplied" do
+      additional_options = { note: 'This is a test' }
+
+      mock_the_response('AddInventoryRs')
+      Fishbowl::Requests.add_inventory(valid_options.merge(additional_options))
+      connection.last_write.should be_equivalent_to(expected_request(additional_options))
+    end
+
+    it "includes tracking option when supplied"
+
+    def expected_request(options = {})
+      options = valid_options.merge(options)
+
+      request = Nokogiri::XML::Builder.new do |xml|
+        xml.FbiXml {
+          xml.Ticket
+          xml.FbiMsgsRq {
+            xml.AddInventoryRq {
+              xml.PartNum options[:part_number]
+              xml.Quantity options[:quantity]
+              xml.UOMID options[:uom_id]
+              xml.Cost options[:cost]
+              xml.Note options[:note] unless options[:note].nil?
+              xml.Tracking options[:tracking] unless options[:tracking].nil?
+              xml.LocationTagNum valid_options[:location_tag_number]
+              xml.TagNum valid_options[:tag_number]
+            }
+          }
+        }
+      end
+
+      request.to_xml
+    end
+  end
+end