qbfc 0.3.0

data/spec/unit/base_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+describe QBFC::Base do
+  
+  before(:each) do 
+    @sess = mock(QBFC::Session)
+    @ole_wrapper = mock(QBFC::OLEWrapper)
+    @ole_methods = ["FullName", "ListID"]
+    @base = QBFC::Base.new(@sess, @ole_wrapper)
+  end
+  
+  it "requires a QBFC:Session argument" do
+    lambda {QBFC::Base.new()}.should raise_error
+    lambda {QBFC::Base.new(@sess)}.should_not raise_error
+  end
+  
+  it "initializes with an optional ole_object argument" do
+    lambda {QBFC::Base.new(@sess, @ole_wrapper)}.should_not raise_error
+  end
+  
+  it "should wrap (only) a WIN32OLE object in an OLEWrapper" do
+    @ole_object = mock(WIN32OLE)
+    @ole_object.should_receive(:kind_of?).with(WIN32OLE).and_return(true)
+    QBFC::OLEWrapper.should_receive(:new).with(@ole_object).and_return(@ole_wrapper)
+
+    QBFC::Base.new(@sess, @ole_object)
+  end
+  
+  it "should not wrap non-WIN32OLE objects" do   
+    @ole_wrapper.should_receive(:kind_of?).with(WIN32OLE).and_return(false)
+    QBFC::OLEWrapper.should_not_receive(:new).with(@ole_object)
+
+    QBFC::Base.new(@sess, @ole_wrapper)
+  end
+  
+  it "lists OLE methods for OLEWrapper object" do
+    @ole_wrapper.should_receive(:ole_methods).and_return(@ole_methods)
+    @base.ole_methods.should be(@ole_methods)
+  end
+  
+  it "has a respond_to_ole? method" do
+    @ole_wrapper.should_receive(:respond_to_ole?).with("FullName").and_return(true)
+    @base.respond_to_ole?("FullName").should be_true
+    
+    @ole_wrapper.should_receive(:respond_to_ole?).with("NoMethod").and_return(false)
+    @base.respond_to_ole?("NoMethod").should be_false
+  end
+  
+  it "should pass unknown method calls to OLEWrapper#qbfc_method_missing" do
+    @ole_wrapper.should_receive(:qbfc_method_missing).with(@sess, :full_name=, "arg")
+    @base.full_name = "arg"
+  end
+  
+  it "has a qb_name class method" do
+    QBFC::Base.qb_name.should == "Base"
+  end
+  
+  it "aliases qb_name class method as an instance method" do
+    @base.qb_name.should == QBFC::Base.qb_name
+  end
+  
+  it "should create_query" do
+    QBFC::Request.should_receive(:new).with(@sess, "BaseQuery")
+    QBFC::Base.__send__(:create_query, @sess)
+  end
+  
+  it "should should respond to is_base_class? with false" do
+    QBFC::Base.is_base_class?.should be_false
+  end
+  
+  describe ".parse_find_args" do
+    before(:each) do
+      @options = {:include_items => true, :owner_id => 0, :conditions => {}}
+    end
+  
+    it "should return a Request object if given one" do
+      rq, opt, base_opt = QBFC::Test::ElementFind.__send__(:parse_find_args, @request, @options)
+      rq.should be(@request)
+      
+      rq, opt, base_opt = QBFC::Test::ElementFind.__send__(:parse_find_args, @request)
+      rq.should be(@request)
+    end
+    
+    it "should return nil request if no Request given" do
+      rq, opt, base_opt = QBFC::Test::ElementFind.__send__(:parse_find_args, @options)
+      rq.should be_nil
+
+      rq, opt, base_opt = QBFC::Test::ElementFind.__send__(:parse_find_args)
+      rq.should be_nil
+    end
+    
+    it "should return dup of options if given them" do
+      rq, opt, base_opt = QBFC::Test::ElementFind.__send__(:parse_find_args, @request, @options)
+      opt.should == @options
+      
+      rq, opt, base_opt = QBFC::Test::ElementFind.__send__(:parse_find_args, @options)
+      opt.should == @options
+    end
+    
+    it "should return an empty hash for options if not given them" do
+      rq, opt, base_opt = QBFC::Test::ElementFind.__send__(:parse_find_args, @request)
+      opt.should == {}
+      
+      rq, opt, base_opt = QBFC::Test::ElementFind.__send__(:parse_find_args)
+      opt.should == {}
+    end
+    
+    it "should return base_options if is_base_class?" do
+      rq, opt, base_opt = QBFC::Test::BaseFind.__send__(:parse_find_args, {})
+      base_opt.should == {}
+    end
+    
+    it "should make base_options and options separate objects" do
+      rq, opt, base_opt = QBFC::Test::BaseFind.__send__(:parse_find_args, @options)
+      base_opt.should_not be(opt)
+    end
+    
+    it "should return nil for base_options if isn't a base class" do
+      rq, opt, base_opt = QBFC::Test::ElementFind.__send__(:parse_find_args, {})
+      base_opt.should be_nil
+    end
+    
+    it "should delete :conditions from base_options" do
+      rq, opt, base_opt = QBFC::Test::BaseFind.__send__(:parse_find_args, @options)
+      base_opt.should == {:include_items => true, :owner_id => 0}
+    end
+
+    it "should delete :owner_id from options if a base class" do
+      rq, opt, base_opt = QBFC::Test::BaseFind.__send__(:parse_find_args, @options)
+      opt.should == {:include_items => true, :conditions => {}}    
+    end
+    
+    it "should not delete :owner_id if not a base class" do
+      rq, opt, base_opt = QBFC::Test::ElementFind.__send__(:parse_find_args, @options)
+      opt.should == {:include_items => true, :owner_id => 0, :conditions => {}}
+    end
+  end
+end

data/spec/unit/element_finder_spec.rb

@@ -0,0 +1,185 @@
+require 'spec_helper'
+
+module QBFC::Test
+  class BaseFind < QBFC::Element
+    is_base_class
+    
+    ID_NAME = "ListID"
+    
+    def self.qb_name
+      "Entity"
+    end
+  end
+  
+  class ElementFind < QBFC::Element
+    def self.qb_name
+      "Check"
+    end
+  end
+end
+
+# An Element is a Transaction or a List; that is any QuickBooks objects that can
+# be created, edited (possibly), deleted and read. Contrast to a Report or Info
+# which are read-only.
+describe QBFC::Element do
+
+  before(:each) do 
+    @sess = mock(QBFC::Session)
+    @ole_wrapper = mock(QBFC::OLEWrapper)
+    @element = mock(QBFC::Test::ElementFind)
+    
+    # Request related mocks
+    @request = mock("QBFC::Request")
+    @request.stub!(:kind_of?).with(QBFC::Request).and_return(true)
+    @request.stub!(:kind_of?).with(Hash).and_return(false)
+    @request.stub!(:dup).and_return(@request)
+    @response = mock("QBFC::Request#response")
+    
+    # Filter mock
+    @filter = mock("QBFC::OLEWrapper#Filter")
+    @request.stub!(:filter).and_return(@filter)
+    @request.stub!(:add_limit)
+    @request.stub!(:filter_available?).and_return(true)
+    @request.stub!(:apply_options)
+  end
+  
+  def setup_request
+    QBFC::Request.stub!(:new).and_return(@request)
+    @request.stub!(:response).and_return(@response)
+    @response.stub!(:GetAt).and_return(@ole_wrapper)
+    @response.stub!(:ole_methods).and_return(["GetAt"])
+    @response.stub!(:Count).and_return(2)
+
+    QBFC::Test::ElementFind.should_receive(:new).with(@sess, @ole_wrapper).at_least(:once).and_return(@element)
+  end
+
+  describe ".find" do
+  
+    it "should find_by_unique_id if the 'what' argument is neither :all nor :first" do
+      QBFC::Test::ElementFind::should_receive(:find_by_unique_id).with(@sess, "123-456", {})
+      QBFC::Test::ElementFind::find(@sess, "123-456", {})
+    end
+    
+    it "should return only first entry if 'what' argument is :first" do  
+      setup_request
+      QBFC::Test::ElementFind::find(@sess, :first).should be(@element)
+    end
+    
+    it "should set request#max_returned to 1 if :first" do
+      setup_request
+      @request.should_receive(:add_limit).with(1)
+      @request.stub!(:filter_available?).and_return(true)
+      QBFC::Test::ElementFind::find(@sess, :first)
+    end
+
+    it "should not set request#max_returned if not request.filter_available?" do
+      setup_request
+      @request.stub!(:filter_available?).and_return(false)
+      @request.should_not_receive(:add_limit)
+      QBFC::Test::ElementFind::find(@sess, :first)
+    end
+
+    it "should return an array if 'what' argument is :all" do
+      setup_request
+      @filter.should_not_receive(:max_returned=)
+      QBFC::Test::ElementFind::find(@sess, :all).should == [@element, @element]
+    end
+    
+    it "should return nil if no elements are found unless finding :first" do
+      QBFC::Request.should_receive(:new).with(@sess, 'CheckQuery').and_return(@request)
+      @request.should_receive(:response).and_return(nil)
+      QBFC::Test::ElementFind::find(@sess, :first).should be_nil
+    end
+    
+    it "should return an empty array if no elements are found when finding :all" do
+      QBFC::Request.should_receive(:new).with(@sess, 'CheckQuery').and_return(@request)
+      @request.should_receive(:response).and_return(nil)
+      QBFC::Test::ElementFind::find(@sess, :first).should be_nil
+    end
+    
+    it "should call Base.parse_find_args" do
+      setup_request
+      QBFC::Test::ElementFind::should_receive(:parse_find_args).with({:option => true})
+      QBFC::Test::ElementFind::find(@sess, :all, {:option => true})
+    end
+    
+    it "applies options to request" do
+      setup_request
+      @request.should_receive(:apply_options).with({:owner_id => 0})
+      QBFC::Test::ElementFind::find(@sess, :first, :owner_id => 0)
+    end
+    
+    it "should get request#response" do
+      setup_request
+      @request.should_receive(:response).and_return(@response)    
+      QBFC::Test::ElementFind::find(@sess, :first)
+    end
+    
+    it "should call base_class_find for base classes" do
+      QBFC::Request.stub!(:new).and_return(@request)
+      QBFC::Test::BaseFind.should_receive(:base_class_find).with(@sess, :first, @request, {}).and_return(@element)
+      QBFC::Test::BaseFind::find(@sess, :first, {}).should be(@element)
+    end
+    
+    it "should not call base_class_find for non-base classes" do
+      setup_request
+      QBFC::Test::ElementFind.should_not_receive(:base_class_find)
+      QBFC::Test::ElementFind::find(@sess, :first, {})      
+    end
+  end
+
+  describe ".base_class_find" do
+    before(:each) do
+      @include_list = mock("IncludeRetElementList")
+      @request.stub!(:IncludeRetElementList).and_return(@include_list)
+      @include_list.stub!(:Add).with("ListID")
+      @request.stub!(:response).and_return(@response)
+      QBFC::Request.stub!(:new).and_return(@request)
+      
+      @element = mock(QBFC::Test::ElementFind)
+      @base_element = mock(QBFC::Test::BaseFind)
+      @customer_ret = mock("CustomerRet")
+      @list_id = mock("ListID")
+      @base_element.stub!(:ole_methods).and_return(["VendorRet", "CustomerRet"])
+      @base_element.stub!(:VendorRet).and_return(nil)
+      @base_element.stub!(:CustomerRet).and_return(@customer_ret)
+      @customer_ret.stub!(:ListID).and_return(@list_id)
+      @list_id.stub!(:GetValue).and_return("123-456")
+      QBFC::Customer.stub!(:find_by_id).and_return(@element)
+
+      @response.stub!(:GetAt).and_return(@base_element)
+      @response.stub!(:Count).and_return(2)
+    end
+
+    it "should request only ListID" do
+      @include_list.should_receive(:Add).with("ListID")
+      QBFC::Test::BaseFind.find(@sess, :first, @request, {})
+    end
+    
+    it "should send class ChildList::find_by_id with ListID and find options for each" do
+      @base_element.should_receive(:CustomerRet).at_least(:once).and_return(@customer_ret)
+      @customer_ret.should_receive(:ListID).at_least(:once).and_return(@list_id)
+      @list_id.should_receive(:GetValue).at_least(:once).and_return("789-012")
+      QBFC::Customer.should_receive(:find_by_id).at_least(:once).with(@sess, "789-012", {}).and_return(@element)
+      QBFC::Test::BaseFind.find(@sess, :first, @request, {}).should be(@element)
+    end
+    
+    it "should return nil if no records and not :all" do
+      @request.should_receive(:response).and_return(nil)
+      QBFC::Test::BaseFind.find(@sess, :first, @request, {}).should be_nil
+    end
+    
+    it "should return nil if no records and not :all" do
+      @request.should_receive(:response).and_return(nil)
+      QBFC::Test::BaseFind.find(@sess, :all, @request, {}).should == []
+    end    
+    
+    it "should return single record unless :all" do
+      QBFC::Test::BaseFind.find(@sess, :first, @request, {}).should be(@element)
+    end
+    
+    it "should return Array if :all" do
+      QBFC::Test::BaseFind.find(@sess, :all, @request, {}).should == [@element, @element]
+    end
+  end
+end

data/spec/unit/element_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+module QBFC::Test
+  class BaseKlass < QBFC::Element
+    is_base_class
+  end
+  
+  class NormalKlass < QBFC::Element
+  end
+end
+
+# An Element is a Transaction or a List; that is any QuickBooks objects that can
+# be created, edited (possibly), deleted and read. Contrast to a Report or Info
+# which are read-only.
+describe QBFC::Element do
+
+  before(:each) do 
+    @sess = mock(QBFC::Session)
+    @ole_wrapper = mock(QBFC::OLEWrapper)
+    @ole_object = mock(WIN32OLE)
+    @ole_methods = ["FullName", "DataExtRetList"]
+    @element = QBFC::Test::NormalKlass.new(@sess, @ole_wrapper)
+  end
+
+  describe "#initialize" do
+    it "should set up add request if ole_object is nil" do
+      @request = mock(QBFC::Request)
+      @request.should_receive(:ole_object).and_return(@ole_object)
+      QBFC::Request.should_receive(:new).with(@sess, "NormalKlassAdd").and_return(@request)
+      QBFC::Test::NormalKlass.new(@sess)
+    end
+    
+    it "should assign the Add request as the @setter" do
+      @request = mock(QBFC::Request)
+      @request.stub!(:ole_object).and_return(@ole_object)
+      QBFC::Request.should_receive(:new).with(@sess, "NormalKlassAdd").and_return(@request)
+      QBFC::Test::NormalKlass.new(@sess).
+          instance_variable_get(:@setter).should == @request
+    end
+  end
+  
+  describe "#new_record?" do
+    before(:each) do
+      @request = mock(QBFC::Request)
+      @request.stub!(:ole_object).and_return(@ole_object)
+      QBFC::Request.stub!(:new).with(@sess, "NormalKlassAdd").and_return(@request)
+    end
+    
+    it "should return true if ole_object is an AddRq" do
+      QBFC::Test::NormalKlass.new(@sess).new_record?.should be_true
+    end
+
+    it "should return false if ole_object is from a QueryRq" do
+      @element.new_record?.should be_false
+    end
+  end
+  
+  describe ".is_base_class? (and is_base_class macro)" do
+    it "should return true if Class is_base_class has been called" do
+      QBFC::Test::BaseKlass.is_base_class?.should be_true
+      QBFC::Test::NormalKlass.is_base_class?.should be_false
+    end
+  end
+  
+  describe "#custom" do
+    before(:each) do
+      @data_ext = mock("QBFC::OLEWrapper#DataExtRet")
+      @data_ext_list = [@data_ext, @data_ext]
+      @ole_wrapper.stub!(:DataExtRetList).and_return(@data_ext_list)
+      @ole_wrapper.stub!(:data_ext).and_return(@data_ext_list)
+    end
+  
+    it "should get custom fields" do
+      @data_ext.should_receive(:data_ext_name).and_return("Custom Field")
+      @data_ext.should_receive(:owner_id).and_return('0')
+      @data_ext.should_receive(:data_ext_value).and_return("Hello")
+      
+      @element.custom("Custom Field").should == "Hello"
+    end
+    
+    it "should return nil if there are no custom fields" do
+      @ole_wrapper.should_receive(:DataExtRetList).and_return(nil)
+      
+      @element.custom("Custom Field").should be_nil
+    end
+    
+    it "should return nil if the custom field is not found" do
+      @data_ext.should_receive(:data_ext_name).twice.and_return("Custom Field")
+      
+      @element.custom("No Field").should be_nil
+    end
+  end
+  
+  describe "#save" do
+    it "should submit the setter object" do
+      @request = mock(QBFC::Request)
+      @request.stub!(:ole_object).and_return(@ole_object)
+      QBFC::Request.should_receive(:new).with(@sess, "NormalKlassAdd").and_return(@request)
+      @request.should_receive(:submit)
+
+      QBFC::Test::NormalKlass.new(@sess).save
+    end
+    
+    it "should raise an error if there is no setter object" do
+      lambda { @element.save}.should raise_error(QBFC::NotSavableError)
+    end
+  end
+end

data/spec/unit/entities/generated_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe "QBFC::Entity generated.rb" do
+  
+  it "should generate classes" do
+    QBFC::Customer.superclass.should be(QBFC::Entity)
+    QBFC::Vendor.superclass.should be(QBFC::Entity)
+    QBFC::OtherName.superclass.should be(QBFC::Entity)
+    QBFC::Employee.superclass.should be(QBFC::Entity)
+  end
+  
+  it "should include Modifiable in all classes" do
+    QBFC::Customer.included_modules.should include(QBFC::Modifiable)
+    QBFC::Vendor.included_modules.should include(QBFC::Modifiable)
+    QBFC::OtherName.included_modules.should include(QBFC::Modifiable)
+    QBFC::Employee.included_modules.should include(QBFC::Modifiable)
+  end
+end