jm81-qbfc 0.3.0

data/spec/unit/qb_collection_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe QBFC::QBCollection do
+
+  before(:each) do
+    @sess = mock(QBFC::Session)
+  end
+
+  it "should send missing methods to the Class specified, with the Session" do
+    QBFC::Customer.should_receive(:find).with(@sess, :all)
+    QBFC::QBCollection.new(@sess, 'Customer').find(:all)
+  end
+end

data/spec/unit/qbfc_const_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe QBFC_CONST do
+
+  it "should load QBFC constants" do
+    QBFC_CONST::DmToday.should == 1
+    QBFC_CONST::OmDontCare.should == 2
+  end
+
+end

data/spec/unit/qbfc_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe QBFC do
+
+  it "should have a session method which calls QBFC::Session.open" do
+    QBFC::Session.should_receive(:open).with({:filename => "file"})
+    QBFC::session({:filename => "file"})
+  end
+
+end

data/spec/unit/report_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe QBFC::Report do
+
+  describe ".get_class" do
+    it "should get the class for this report" do
+      QBFC::Report.get_class("AuditTrail").should be(QBFC::Reports::GeneralDetail)
+      QBFC::Report.get_class("PayrollSummary").should be(QBFC::Reports::PayrollSummary)
+      QBFC::Report.get_class("TimeByJobDetail").should be(QBFC::Reports::Time)
+    end
+  end
+end

data/spec/unit/request_query_survey.txt

@@ -0,0 +1,48 @@
+These are notes from a "survey" through possible options for Query Requests.
+This is intended to inform what specs are added to Request (particularly 
+#apply_options and the methods it calls).
+
+lists
+  - list_id_list
+  - full_name_list
+  - txn_id_list
+  X ref_number_list
+  - ref_number_case_sensitive_list
+  
+filters
+  - max_returned (alias limit)
+  - active_status (alias active)
+  
+  - from_modified_date (for lists)
+  - to_modified_date (for lists)
+  
+  - ORDateRangeFilter
+    - modified_date_range_filter (from and to)
+    - txn_date_range_filter (from and to OR macro)
+
+  - entity_filter / account_filter / item_filter (all ORs)
+    - ListIDList, FullNameList, ListIDWithChildren, FullNameWithChildren
+
+  - ORNameFilter / ORRefNumFilter
+    - name_filter (has criterion and name)
+    - name_range_filter (from and to)
+  
+  - time_tracking_entity_filter
+  
+  - ItemRef
+    
+  - account_type_list
+  
+  - txn_filter_no_account (SalesOrder)
+  
+  - pending_status
+  - paid_status
+  - done_status
+  
+TransactionQuery has a bunch of extras
+  
+includes
+  - include_ret_element_list
+  - include_line_items
+  - include_linked_txns
+  - IncludeComponentLineItems

data/spec/unit/request_spec.rb

@@ -0,0 +1,486 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe QBFC::Request do
+
+  before(:each) do
+    @sess = mock(QBFC::Session)
+    @request_set = mock(QBFC::OLEWrapper)
+    @ole_request = mock(QBFC::OLEWrapper)
+
+    @sess.stub!(:CreateMsgSetRequest).and_return(@request_set)
+    @request_set.stub!(:AppendCustomerQueryRq).and_return(@ole_request)
+  end
+
+  it "sends CreateMsgSetRequest to Quickbooks Session" do
+    @sess.should_receive(:CreateMsgSetRequest).with('US', 6, 0).and_return(@request_set)
+    QBFC::Request.new(@sess, 'CustomerQuery')
+  end
+  
+  it "appends a query to MsgSetRequest" do
+    @request_set.should_receive(:AppendCustomerQueryRq).and_return @ole_request
+    QBFC::Request.new(@sess, 'CustomerQuery')
+  end
+
+  it "accepts version information" do
+    @sess.should_receive(:CreateMsgSetRequest).with('CA', 5, 5).and_return(@request_set)
+    QBFC::Request.new(@sess, 'CustomerQuery', 'CA', 5, 5)
+  end
+  
+  it "should raise a QBFC::QBXMLVersionError if the version is not supported" do
+    @sess.should_receive(:CreateMsgSetRequest).and_raise(WIN32OLERuntimeError.new('error code:8004030A'))
+    lambda { QBFC::Request.new(@sess, 'CustomerQuery')}.should raise_error(QBFC::QBXMLVersionError)
+  end
+  
+  it "should re-raise errors other than QBXMLVersionError" do
+    @sess.should_receive(:CreateMsgSetRequest).and_raise(WIN32OLERuntimeError.new('error'))
+    lambda { QBFC::Request.new(@sess, 'CustomerQuery')}.should raise_error(WIN32OLERuntimeError)
+  end
+    
+  it "should raise a QBFC::UnknownRequestError if the request is not supported" do
+    @request_set.should_receive(:AppendCustomerQueryRq).and_raise(WIN32OLERuntimeError.new('error code:0x80020006'))
+    lambda { QBFC::Request.new(@sess, 'CustomerQuery')}.should raise_error(QBFC::UnknownRequestError)
+  end
+    
+  it "should re-raise errors other than UnknownRequestError" do
+    @request_set.should_receive(:AppendCustomerQueryRq).and_raise(WIN32OLERuntimeError.new('error'))
+    lambda { QBFC::Request.new(@sess, 'CustomerQuery')}.should raise_error(WIN32OLERuntimeError)
+  end
+  
+  it "should show ole_methods" do
+    @ole_request.should_receive(:ole_methods)
+    QBFC::Request.new(@sess, 'CustomerQuery').ole_methods
+  end
+  
+  it "gives direct access to the request's ole_object" do
+    @ole_request.should_receive(:ole_object).and_return("OLEObject")
+    QBFC::Request.new(@sess, 'CustomerQuery').ole_object.should == "OLEObject"
+  end
+  
+  it "should have the OLEWrapper object handle missing methods" do
+    @ole_request.should_receive(:qbfc_method_missing).with(@sess, :no_method)
+    QBFC::Request.new(@sess, 'CustomerQuery').no_method
+
+    @ole_request.should_receive(:qbfc_method_missing).with(@sess, :NoMethod)
+    QBFC::Request.new(@sess, 'CustomerQuery').NoMethod
+  end
+  
+  it "should return xml of the request" do
+    @request_set.should_receive(:ToXMLString)
+    QBFC::Request.new(@sess, 'CustomerQuery').to_xml
+  end
+  
+  describe "#response" do
+    before(:each) do
+      @sess = mock(QBFC::Session)
+      @request_set = mock(QBFC::OLEWrapper)
+      @ole_request = mock(QBFC::OLEWrapper)
+  
+      @sess.stub!(:CreateMsgSetRequest).and_return(@request_set)
+      @request_set.stub!(:AppendCustomerQueryRq).and_return(@ole_request)
+    
+      @response_set = mock("DoRequestsRespost")
+      @response_list = mock("ResponseList")
+      @response = mock("GetAt")
+      @detail = mock("Detail")
+      
+      @sess.stub!(:DoRequests).and_return @response_set
+      @response_set.stub!(:ResponseList).and_return @response_list
+      @response_list.stub!(:GetAt).and_return @response
+      @response.stub!(:Detail).and_return @detail
+    end
+  
+    it "gets a response" do
+      @sess.should_receive(:DoRequests).and_return @response_set
+      @response_set.should_receive(:ResponseList).and_return @response_list
+      @response_list.should_receive(:GetAt).with(0).and_return @response
+      @response.should_receive(:Detail).and_return @detail
+
+      request = QBFC::Request.new(@sess, 'CustomerQuery')
+
+      request.response.should == @detail
+    end
+    
+    it "returns a nil response if the response has no Detail" do
+      @response.should_receive(:Detail).and_return nil
+    
+      request = QBFC::Request.new(@sess, 'CustomerQuery')
+      
+      QBFC::OLEWrapper.should_not_receive(:new)
+      request.response.should be_nil
+    end
+    
+      
+    it "should return xml of the response" do
+      request = QBFC::Request.new(@sess, 'CustomerQuery')      
+      @response_set.should_receive(:ToXMLString)
+      request.response_xml
+    end
+  end
+  
+  describe "#query" do
+    before(:each) do
+      @request = QBFC::Request.new(@sess, 'CustomerQuery')
+      @request.instance_variable_set(:@request, @ole_request)
+      
+      @or_query = mock("OLEWrapper#or_query")    
+    end
+  
+    it "gets the OR*Query for the given Request" do
+      @ole_request.should_receive(:ole_methods).and_return(["TxnID", "RefNumber", "ORTransactionQuery", "OwnerIDList"])
+      @ole_request.should_receive(:ORTransactionQuery).and_return(@or_query)
+      @request.query.should be(@or_query)
+    end
+    
+    it "should return nil if no query name is detected" do
+      @ole_request.should_receive(:ole_methods).and_return(["TxnID", "RefNumber", "OwnerIDList"])
+      @request.query.should be_nil
+    end
+  end
+  
+  describe "#filter" do
+    before(:each) do
+      @request = QBFC::Request.new(@sess, 'CustomerQuery')
+      @request.instance_variable_set(:@request, @ole_request)
+      
+      @or_query = mock("OLEWrapper#or_query")
+      @filter = mock("OLEWrapper#filter")
+      @ole_request.stub!(:ole_methods).and_return(["TxnID", "RefNumber", "ORTransactionQuery", "OwnerIDList"])
+      @ole_request.stub!(:ORTransactionQuery).and_return(@or_query)
+    end
+
+    it "gets the *Filter for the given Request" do
+      @or_query.should_receive(:ole_methods).and_return(["TxnIDList", "RefNumberList", "TransactionFilter"])
+      @or_query.should_receive(:TransactionFilter).and_return(@filter)
+      @request.filter.should be(@filter)
+    end
+    
+    it "should return nil if no filter name is detected" do
+      @or_query.should_receive(:ole_methods).and_return(["TxnIDList", "RefNumberList"])
+      @request.filter.should be_nil
+    end
+    
+    it "should return nil if the #query is nil" do
+      @ole_request.should_receive(:ole_methods).and_return([])
+      @request.filter.should be_nil
+    end
+  end
+
+  describe "#filter_available?" do
+    before(:each) do
+      @request = QBFC::Request.new(@sess, 'CustomerQuery')
+      
+      @or_query = mock("OLEWrapper#or_query")
+      @filter = mock("OLEWrapper#filter")
+      @ole_request.stub!(:ole_methods).and_return(["TxnID", "RefNumber", "ORTransactionQuery", "OwnerIDList", "ortype"])
+      @ole_request.stub!(:ORTransactionQuery).and_return(@or_query)
+      
+      @ole_object = mock(WIN32OLE)
+      @or_query.stub!(:ole_object).and_return(@ole_object)
+      @ole_object.stub!(:ole_object).and_return(["TxnID", "RefNumber", "ORTransactionQuery", "OwnerIDList", "ortype"])
+    end
+
+    it "should be true if no query options have been set" do
+      @ole_object.should_receive(:ortype).at_least(:once).and_return(-1)
+      @request.filter_available?.should be_true
+    end
+    
+    it "should be true if Filter option has been set" do
+      @ole_object.should_receive(:ortype).at_least(:once).and_return(2)
+      @request.filter_available?.should be_true
+    end
+    
+    it "should be false if a *List option has been set" do
+      @ole_object.should_receive(:ortype).at_least(:once).and_return(1)
+      @request.filter_available?.should be_false
+    end
+    
+  end
+  
+  describe "#apply_options" do
+    before(:each) do
+      @request = QBFC::Request.new(@sess, 'CustomerQuery')
+      @query = mock('Request#query')
+      @filter = mock('Request#filter')
+      @request.stub!(:query).and_return(@query)
+    end
+  
+    it "should apply an :owner_id option" do
+      @request.should_receive(:add_owner_ids).with(1)
+      @request.apply_options(:owner_id => 1)
+    end
+
+    it "should apply an :limit option" do
+      @request.should_receive(:add_limit).with(1)
+      @request.apply_options(:limit => 1)
+    end
+    
+    it "should apply an :include option" do
+      include_ary = [1,2,3]
+      @request.should_receive(:add_includes).with(include_ary)
+      @request.apply_options(:include => include_ary)
+    end
+    
+    it "should apply lists to query" do
+      ref_number_list = mock('OLEWrapper#ref_number_list')
+      @query.should_receive(:RefNumberList).and_return(ref_number_list)
+      ref_number_list.should_receive(:Add).with('82')
+      ref_number_list.should_receive(:Add).with('1234')
+
+      @request.apply_options(:conditions => {:ref_number_list => %w{82 1234}})
+    end
+
+    it "should apply lists to query when given a single item" do
+      ref_number_list = mock('OLEWrapper#ref_number_list')
+      @query.should_receive(:RefNumberList).and_return(ref_number_list)
+      ref_number_list.should_receive(:Add).with('20')
+
+      @request.apply_options(:conditions => {:ref_number_list => '20'})
+    end
+    
+    describe "(range)" do
+      before(:each) do
+        @range_filter = mock('Request#TxnDateRangeFilter')
+        @request.stub!(:filter_for).with('txn_date_range').and_return(@range_filter)
+        @request.stub!(:filter_for).with('modified_date_range').and_return(@range_filter)
+        @range_filter.stub!(:from_txn_date=)
+        @range_filter.stub!(:to_txn_date=)
+      end
+    
+      it "should #parse_range_value" do
+        @request.should_receive(:parse_range_value).with([0,2]).and_return([0,2])
+        @request.apply_options(:conditions => {:txn_date_range => [0,2]})
+      end
+      
+      it "should get appropriate filter" do
+        @request.should_receive(:filter_for).with('txn_date_range').and_return(@range_filter)
+        @request.apply_options(:conditions => {:txn_date_range => [0,2]})
+      end
+      
+      it "should apply date range to filter" do
+        @range_filter.should_receive(:from_txn_date=).with(0)
+        @range_filter.should_receive(:to_txn_date=).with(2)
+        @request.apply_options(:conditions => {:txn_date_range => [0,2]})
+      end
+
+      it "should add 'true' argument (asDateOnly) for modified_date ranges" do
+        @range_filter.should_receive(:from_modified_date=).with(0, true)
+        @range_filter.should_receive(:to_modified_date=).with(2, true)
+        @request.apply_options(:conditions => {:modified_date_range => [0,2]})
+      end
+    end
+    
+    describe "(status)" do
+      it "should set status" do
+        @filter = mock('Request#filter')
+        @request.stub!(:filter).and_return(@filter)
+        @filter.should_receive(:paid_status=).with(QBFC_CONST::PsPaidOnly)
+        @request.apply_options(:conditions => {:paid_status => QBFC_CONST::PsPaidOnly})
+      end
+    end
+    
+    describe "(reference)" do
+      before(:each) do
+        @ref_filter = mock('Request#RefFilter')
+        @full_name_list = mock('OLEWrapper#FullNameList')
+        @request.stub!(:filter_for).with('entity').and_return(@ref_filter)
+        @ref_filter.should_receive(:FullNameList).at_least(:once).and_return(@full_name_list)
+        @full_name_list.stub!(:Add)
+      end
+    
+      it "should get appropriate filter" do
+        @request.should_receive(:filter_for).with('entity').and_return(@ref_filter)
+        @request.apply_options(:conditions => {:entity => 'ABC Supplies'})
+      end
+      
+      it "should set a single full name" do
+        @full_name_list.should_receive(:Add).with('ABC Supplies')
+        @request.apply_options(:conditions => {:entity => 'ABC Supplies'})
+      end
+
+      it "should set a single full name (non-string)" do
+        @full_name_list.should_receive(:Add).with(1)
+        @request.apply_options(:conditions => {:entity => 1})
+      end
+      
+      it "should set a multiple full names" do
+        @full_name_list.should_receive(:Add).with('ABC Supplies')
+        @full_name_list.should_receive(:Add).with('CompuStuff')
+        @request.apply_options(:conditions => {:entity => %w{ABC\ Supplies CompuStuff}})
+      end
+    end
+  end
+  
+  describe "#add_includes" do
+    before(:each) do
+      @request = QBFC::Request.new(@sess, 'CustomerQuery')
+      @ret_list = mock('RetElementList')
+      
+      @ole_request.stub!(:respond_to_ole?).with('IncludeLineItems').and_return(true)
+      @ole_request.stub!(:respond_to_ole?).with('IncludeLinkedTxns').and_return(true)
+      @ole_request.stub!(:respond_to_ole?).with('IncludeTxnID').and_return(false)
+      @ole_request.stub!(:respond_to_ole?).with('IncludeCustomerRef').and_return(false)
+    end
+    
+    it "should add specific include requests" do
+      @ole_request.should_receive(:include_line_items=).with(true)
+      @request.__send__(:add_includes, [:line_items])
+    end
+    
+    it "should apply additional includes to IncludeRetElementList" do
+      @ole_request.should_receive(:IncludeRetElementList).twice.and_return(@ret_list)
+      @ret_list.should_receive(:Add).with('TxnID')
+      @ret_list.should_receive(:Add).with('CustomerRef')
+      @request.__send__(:add_includes, [:txn_id, :customer_ref])
+    end
+    
+    it "should include :all" do
+      @ole_request.should_receive(:ole_methods).and_return(%w{ORTxnQuery IncludeLineItems IncludeLinkedTxns iterator})
+      @ole_request.should_receive(:include_line_items=).with(true)
+      @ole_request.should_receive(:include_linked_txns=).with(true)
+      @request.__send__(:add_includes, :all)
+    end
+  end
+  
+  describe "#parse_range_value" do
+    before(:each) do
+      @request = QBFC::Request.new(@sess, 'CustomerQuery')
+    end
+
+    it "should add a nil element to a one-element Array" do
+      ary = [0]
+      @request.__send__(:parse_range_value, ary).should == [0, nil]
+    end
+    
+    it "should return unchanged a multiple element Array" do
+      ary = [0, 1]
+      @request.__send__(:parse_range_value, ary).should be(ary)
+    end
+    
+    it "should return unchanged a Range" do
+      rng = 0..1
+      @request.__send__(:parse_range_value, rng).should be(rng)
+    end
+    
+    it "should take a scalar and return an array with the second element nil" do
+      val = 0
+      @request.__send__(:parse_range_value, val).should == [val, nil]
+    end
+    
+    it "should take a String scalar and return an array with the second element nil" do
+      val = '0'
+      @request.__send__(:parse_range_value, val).should == [val, nil]
+    end
+  
+  end
+  
+  describe "#filter_for" do
+    before(:each) do
+      @request = QBFC::Request.new(@sess, 'CustomerQuery')
+      @query = mock('Request#query')
+      @filter = mock('Request#filter')
+      @request.stub!(:query).and_return(@query)
+      @request.stub!(:filter).and_return(@filter)
+
+      @or_date_range_filter = mock('Request#ORDateRangeFilter')
+      @or_ref_number_filter = mock('Request#ORRefNumberFilter')
+      @txn_date_range_filter = mock('Request#TxnDateRangeFilter')
+      @final_filter = mock('Request#FinalFilter')
+      
+      @filter.stub!(:respond_to_ole?).and_return(false)
+      @or_date_range_filter.stub!(:respond_to_ole?).and_return(false)
+      @final_filter.stub!(:respond_to_ole?).and_return(false)
+    end
+  
+    it "should follow ORDateRangeFilter for date_ranges" do
+      @filter.should_receive(:respond_to_ole?).with('ORDateRangeFilter').and_return(true)
+      @filter.should_receive(:ORDateRangeFilter).and_return(@or_date_range_filter)
+      @or_date_range_filter.should_receive(:ModifiedDateRangeFilter).and_return(@final_filter)
+      
+      @request.__send__(:filter_for, 'modified_date_range').should be(@final_filter)
+    end
+
+    it "should follow OR{name}Filter" do
+      @filter.should_receive(:respond_to_ole?).with('ORRefNumberFilter').and_return(true)
+      @filter.should_receive(:ORRefNumberFilter).and_return(@or_ref_number_filter)
+      @or_ref_number_filter.should_receive(:RefNumberFilter).and_return(@final_filter)
+      
+      @request.__send__(:filter_for, 'ref_number').should be(@final_filter)
+    end
+    
+    it "should follow OR{name}Filter, with 'Range' removed" do
+      @filter.should_receive(:respond_to_ole?).with('ORRefNumberFilter').and_return(true)
+      @filter.should_receive(:ORRefNumberFilter).and_return(@or_ref_number_filter)
+      @or_ref_number_filter.should_receive(:RefNumberRangeFilter).and_return(@final_filter)
+      
+      @request.__send__(:filter_for, 'ref_number_range').should be(@final_filter)
+    end
+    
+    it "should return #filter if *ModifiedDate in #filter" do
+      @filter.should_receive(:respond_to_ole?).with('FromModifiedDate').and_return(true)
+      @request.__send__(:filter_for, 'modified_date_range').should == @filter
+    end
+    
+    it "should follow OR below the Filter" do
+      @filter.should_receive(:respond_to_ole?).with('TxnDateRangeFilter').and_return(true)
+      @filter.should_receive(:TxnDateRangeFilter).and_return(@txn_date_range_filter)
+      
+      @txn_date_range_filter.should_receive(:respond_to_ole?).with('ORTxnDateRangeFilter').and_return(true)
+      @txn_date_range_filter.should_receive(:ORTxnDateRangeFilter).and_return(@or_date_range_filter)
+      
+      @request.__send__(:filter_for, 'txn_date_range').should be(@or_date_range_filter)
+    end
+
+    it "should get a nested Filter with 'Range' removed" do
+      @filter.should_receive(:respond_to_ole?).with('TxnDateRangeFilter').and_return(true)
+      @filter.should_receive(:TxnDateRangeFilter).and_return(@txn_date_range_filter)
+      
+      @txn_date_range_filter.should_receive(:respond_to_ole?).with('ORTxnDateRangeFilter').and_return(true)
+      @txn_date_range_filter.should_receive(:ORTxnDateRangeFilter).and_return(@or_date_range_filter)
+      
+      @or_date_range_filter.should_receive(:respond_to_ole?).with('TxnDateFilter').and_return(true)
+      @or_date_range_filter.should_receive(:TxnDateFilter).and_return(@final_filter)
+      
+      @request.__send__(:filter_for, 'txn_date_range').should be(@final_filter)
+    end
+  end
+  
+  describe "#add_owner_ids" do
+    before(:each) do
+      @request = QBFC::Request.new(@sess, 'CustomerQuery')
+      @owner_list = mock(QBFC::OLEWrapper)
+    end
+  
+    it "can add a single owner id to the Request" do
+      @ole_request.should_receive(:OwnerIDList).and_return(@owner_list)
+      @owner_list.should_receive(:Add).with(0)
+      @request.add_owner_ids(0)
+    end
+
+    it "can add multiple owner ids to the Request" do
+      ids = ["{6B063959-81B0-4622-85D6-F548C8CCB517}", 0]
+      @ole_request.should_receive(:OwnerIDList).twice.and_return(@owner_list)
+      @owner_list.should_receive(:Add).with(ids[0])
+      @owner_list.should_receive(:Add).with(ids[1])
+      @request.add_owner_ids(ids)
+    end
+
+    it "can accept nil and will do nothing" do
+      @ole_request.should_not_receive(:OwnerIDList)
+      @owner_list.should_not_receive(:Add)
+      @request.add_owner_ids(nil)
+    end
+  end
+  
+  describe "#add_limit" do
+    before(:each) do
+      @request = QBFC::Request.new(@sess, 'CustomerQuery')
+      @filter = mock('Request#filter')
+      @request.stub!(:filter).and_return(@filter)
+    end
+ 
+    it "can should update the filter's max_returned value" do
+      @filter.should_receive(:max_returned=).with(1)
+      @request.add_limit(1)
+    end
+  end
+end