qbfc 0.3.0

data/spec/unit/ole_wrapper_spec.rb

@@ -0,0 +1,337 @@
+require 'spec_helper'
+
+describe QBFC::OLEWrapper do
+  
+  before(:each) do
+    @sess = mock(QBFC::Session)
+    @ole_object = mock(WIN32OLE)
+    @wrapper = QBFC::OLEWrapper.new(@ole_object)
+  end
+
+  it "should initialize with a WIN32OLE object" do
+    lambda{ QBFC::OLEWrapper.new(@ole_object) }.should_not raise_error
+  end
+  
+  it "should initialize with a String name a WIN32OLE server" do
+    WIN32OLE.should_receive(:new).with("ServerName")
+    QBFC::OLEWrapper.new("ServerName")
+  end
+  
+  it "should return ole_methods" do
+    @ole_object.should_receive("ole_methods").and_return([])
+    @wrapper.ole_methods.should == []
+  end
+  
+  it "should check if the OLE object responds to a given ole_method" do
+    @ole_object.should_receive("ole_methods").twice.and_return(["FullName", "ListID"])
+    @wrapper.respond_to_ole?(:FullName).should_not be_false
+    @wrapper.respond_to_ole?(:NonMethod).should be_nil
+  end
+  
+  it "should make a list responding to GetAt act as an Array" do
+    @get_at_object = mock(WIN32OLE)
+    @get_at_wrapper = QBFC::OLEWrapper.new(@get_at_object)
+    
+    @ole_object.should_receive("GetAt").with(1).and_return(@get_at_object)
+    QBFC::OLEWrapper.should_receive(:new).with(@get_at_object).and_return(@get_at_wrapper)
+    
+    @wrapper[1].should == @get_at_wrapper
+  end
+  
+  it "should pass non-integer values to [] on to ole_object" do
+    @ole_object.should_receive("[]").with('1').and_return("Second Object")
+    @wrapper['1'].should == "Second Object"  
+  end
+  
+  describe "QBFC::OLEWrapper#qbfc_method_missing" do
+  
+    before(:each) do
+      @sess = mock(QBFC::Session)
+      @ole_object = mock(WIN32OLE)
+      @wrapper = QBFC::OLEWrapper.new(@ole_object)
+      
+      @full_name = mock('WIN32OLE.FullName')
+      @full_name.stub!(:ole_methods).and_return(['GetValue', 'SetValue'])
+      
+      @ole_object.stub!(:FullName).and_return(@full_name)
+      @ole_object.stub!(:ole_methods).and_return(['FullName', 'LineRetList', 'PayeeEntityRef', 'AccountRef', 'TimeModified', 'ListID', 'ORInvoiceLineRetList', 'ColDataList', 'ORReportDataList', 'colID'])
+    end
+    
+    it "should call a capitalized method directly" do
+      @ole_object.should_receive(:TestValue).and_return(0)
+      QBFC::OLEWrapper.should_not_receive(:new)
+      
+      @wrapper.qbfc_method_missing(@sess, :TestValue).should == 0
+    end
+    
+    it "should call a capitalized method directly and wrap in OLEWrapper if it returns a WIN32OLE" do
+      @full_name = WIN32OLE.new("QBFC6.QBSessionManager")
+      @ole_object.should_receive(:FullName).and_return(@full_name)
+      @full_name.should_not_receive(:GetValue)
+      
+      @full_name_wrapper = QBFC::OLEWrapper.new(@ole_object)
+      QBFC::OLEWrapper.should_receive(:new).with(@full_name).and_return(@full_name_wrapper)
+      
+      @wrapper.qbfc_method_missing(@sess, :FullName).should == @full_name_wrapper
+    end
+
+    it "should act as a getter method" do
+      @ole_object.should_receive(:FullName).and_return(@full_name)
+      @full_name.should_receive(:GetValue).and_return('Full Name')
+      
+      @wrapper.qbfc_method_missing(@sess, :full_name).should == 'Full Name'
+    end
+         
+    it "should convert 'Id' to 'ID' in getter" do
+      @ole_object.should_receive(:ListID).and_return(@full_name)
+      @full_name.should_receive(:GetValue).and_return('{123-456}')
+      
+      @wrapper.qbfc_method_missing(@sess, :list_id).should == '{123-456}'
+    end
+    
+    it "should convert return of date/time getter methods to Time" do
+      time_modified = @full_name
+      @ole_object.should_receive(:TimeModified).and_return(time_modified)
+      time_modified.should_receive(:GetValue).and_return('2007-01-01 10:00:00')
+      
+      ret = @wrapper.qbfc_method_missing(@sess, :time_modified)
+      ret.should be_kind_of(Time)
+      ret.strftime("%Y-%m-%d %H:%M:%S").should == '2007-01-01 10:00:00'
+    end
+    
+    it "should wrap WIN32OLE objects returned by getter that don't respond to GetValue" do
+      @full_name = WIN32OLE.new("QBFC6.QBSessionManager")
+      @ole_object.should_receive(:FullName).and_return(@full_name)
+      @full_name.should_receive(:ole_methods).and_return(['SetValue'])
+      @full_name.should_not_receive(:GetValue)
+      
+      @full_name_wrapper = QBFC::OLEWrapper.new(@ole_object)
+      QBFC::OLEWrapper.should_receive(:new).with(@full_name).and_return(@full_name_wrapper)
+      
+      @wrapper.qbfc_method_missing(@sess, :full_name).should == @full_name_wrapper
+    end
+    
+    it "should wrap @setter if applicable when wrapping WIN32OLE objects returned by getter " do
+      @setter = mock(WIN32OLE)
+      @setter.should_receive("ole_methods").and_return(["FullName", "ListID"])
+      @wrapper = QBFC::OLEWrapper.new(@ole_object, @setter)
+
+      @full_name_getter = WIN32OLE.new("QBFC6.QBSessionManager")
+      @full_name_setter = WIN32OLE.new("QBFC6.QBSessionManager")
+      @ole_object.should_receive(:FullName).and_return(@full_name_getter)
+      @full_name_getter.should_receive(:ole_methods).and_return(['SetValue'])
+      @setter.should_receive(:FullName).and_return(@full_name_setter)
+      
+      @full_name_wrapper = QBFC::OLEWrapper.new(@full_name_getter, @full_name_setter)
+      QBFC::OLEWrapper.should_receive(:new).with(@full_name_getter, @full_name_setter).and_return(@full_name_wrapper)
+      
+      @wrapper.qbfc_method_missing(@sess, :full_name).should == @full_name_wrapper
+    end
+    
+    it "should return non-WIN32OLE returned by getter that don't respond to GetValue" do
+      @ole_object.should_receive(:FullName).and_return('Full Name')
+      @full_name.should_not_receive(:GetValue)
+      @wrapper.qbfc_method_missing(@sess, :full_name).should == 'Full Name'
+    end
+    
+    it "should act as a setter method" do
+      @ole_object.should_receive(:FullName).and_return(@full_name)
+      @full_name.should_receive(:SetValue).with('Full Name')
+      
+      @wrapper.qbfc_method_missing(@sess, :full_name=, 'Full Name')
+    end
+    
+    it "should convert Dates in setter method" do
+      @ole_object.should_receive(:TimeModified).and_return(@full_name)
+      @full_name.should_receive(:SetValue).with('2008-01-01')
+      
+      @wrapper.qbfc_method_missing(@sess, :time_modified=, Date.parse('2008-01-01'))
+    end
+
+    it "should set @setter also when acting as a setter method, if applicable" do
+      @setter = mock(WIN32OLE)
+      @setter.should_receive("ole_methods").and_return(["FullName", "ListID"])
+      @wrapper = QBFC::OLEWrapper.new(@ole_object, @setter)
+
+      @full_name_setter = WIN32OLE.new("QBFC6.QBSessionManager")      
+      @setter.should_receive(:FullName).and_return(@full_name_setter)
+      @full_name.should_receive(:SetValue).with('Full Name')
+      @full_name_setter.should_receive(:SetValue).with('Full Name')
+      
+      @wrapper.qbfc_method_missing(@sess, :full_name=, 'Full Name')
+    end
+
+    it "should convert 'Id' to 'ID' in setter" do
+      @ole_object.should_receive(:ListID).and_return(@full_name)
+      @full_name.should_receive(:SetValue).and_return('{123-456}')
+      
+      @wrapper.qbfc_method_missing(@sess, :list_id=, '{123-456}')
+    end
+    
+    it "should raise SetValueMissing error on a setter call for a method without SetValue" do
+      @ole_object.should_receive(:FullName).and_return(@full_name)
+      @full_name.should_receive(:ole_methods).and_return(['GetValue'])
+      
+      lambda { @wrapper.qbfc_method_missing(@sess, :full_name=, 'Full Name') }.
+        should raise_error(QBFC::SetValueMissing)
+    end
+    
+    it "should wrap *RetList objects in an Array" do
+      ret_list = mock('WIN32OLE.RetList')
+      ret_list.stub!(:ole_methods).and_return(['GetAt', 'Count'])
+      ret_list.should_receive(:Count).and_return(2)
+      ret_list.should_receive(:GetAt).with(0).and_return(@full_name)
+      ret_list.should_receive(:GetAt).with(1).and_return(@full_name)
+    
+      @ole_object.should_receive(:LineRetList).and_return(ret_list)
+      
+      @full_name_wrapper = QBFC::OLEWrapper.new(@full_name)
+      QBFC::OLEWrapper.should_receive(:new).with(@full_name).twice.and_return(@full_name_wrapper)
+      
+      @wrapper.qbfc_method_missing(@sess, :lines).should ==
+        [@full_name_wrapper, @full_name_wrapper]
+    end
+    
+    it "should wrap OR*RetList objects in an Array" do
+      ret_list = mock('WIN32OLE.ORInvoiceLineRetList')
+      list_item_wrapper = mock('WIN32OLE.InvoiceLineRetWrapper')
+      list_item = mock('WIN32OLE.InvoiceLineRet')
+      ret_list.stub!(:ole_methods).and_return(['GetAt', 'Count'])
+      ret_list.should_receive(:Count).and_return(2)
+      ret_list.should_receive(:GetAt).with(0).and_return(list_item_wrapper)
+      ret_list.should_receive(:GetAt).with(1).and_return(list_item_wrapper)
+      list_item_wrapper.should_receive(:InvoiceLineRet).twice.and_return(list_item)
+    
+      @ole_object.should_receive(:ORInvoiceLineRetList).and_return(ret_list)
+      
+      @wrapper.qbfc_method_missing(@sess, :invoice_lines).should ==
+        [list_item, list_item]
+    end
+    
+    it "should wrap *List objects in an Array" do
+      ret_list = mock('WIN32OLE.List')
+      ret_list.stub!(:ole_methods).and_return(['GetAt', 'Count'])
+      ret_list.should_receive(:Count).and_return(2)
+      ret_list.should_receive(:GetAt).with(0).and_return(@full_name)
+      ret_list.should_receive(:GetAt).with(1).and_return(@full_name)
+    
+      @ole_object.should_receive(:ColDataList).and_return(ret_list)
+      
+      @full_name_wrapper = QBFC::OLEWrapper.new(@full_name)
+      QBFC::OLEWrapper.should_receive(:new).with(@full_name).twice.and_return(@full_name_wrapper)
+      
+      @wrapper.qbfc_method_missing(@sess, :col_datas).should ==
+        [@full_name_wrapper, @full_name_wrapper]
+    end
+    
+    it "should wrap OR*List objects in an Array" do
+      ret_list = mock('WIN32OLE.ORInvoiceLineList')
+      list_item_wrapper = mock('WIN32OLE.InvoiceLineWrapper')
+      list_item = mock('WIN32OLE.InvoiceLine')
+      ret_list.stub!(:ole_methods).and_return(['GetAt', 'Count'])
+      ret_list.should_receive(:Count).and_return(2)
+      ret_list.should_receive(:GetAt).with(0).and_return(list_item_wrapper)
+      ret_list.should_receive(:GetAt).with(1).and_return(list_item_wrapper)
+      list_item_wrapper.should_receive(:ReportData).twice.and_return(list_item)
+    
+      @ole_object.should_receive(:ORReportDataList).and_return(ret_list)
+      
+      @wrapper.qbfc_method_missing(@sess, :report_datas).should ==
+        [list_item, list_item]
+    end
+    
+    it "should call a lower-case method defined by QBFC" do
+      @ole_object.should_receive(:colID).and_return('Id')
+      @wrapper.qbfc_method_missing(@sess, :colID).should == 'Id'
+    end
+    
+    it "should have *_full_name for *Ref" do
+      ref = mock('WIN32OLE.PayeeRef')
+      @ole_object.should_receive(:AccountRef).and_return(ref)
+
+      full_name = "Full Name"
+      full_name_obj = mock('WIN32OLE.FullName')
+      ref.should_receive(:FullName).and_return(full_name_obj)
+      full_name_obj.should_receive(:GetValue).and_return(full_name)
+      
+      @wrapper.qbfc_method_missing(@sess, :account_full_name).should == full_name
+    end
+    
+    it "should have *_id for *Ref" do
+      ref = mock('WIN32OLE.PayeeRef')
+      @ole_object.should_receive(:AccountRef).and_return(ref)
+
+      list_id = "1"
+      list_id_obj = mock('WIN32OLE.ListID')
+      ref.should_receive(:ListID).and_return(list_id_obj)
+      list_id_obj.should_receive(:GetValue).and_return(list_id)
+      
+      @wrapper.qbfc_method_missing(@sess, :account_id).should == list_id
+    end
+    
+    it "should have *_full_name for *EntityRef" do
+      ref = mock('WIN32OLE.PayeeEntityRef')
+      @ole_object.should_receive(:PayeeEntityRef).and_return(ref)
+
+      full_name = "Full Name"
+      full_name_obj = mock('WIN32OLE.FullName')
+      ref.should_receive(:FullName).and_return(full_name_obj)
+      full_name_obj.should_receive(:GetValue).and_return(full_name)
+      
+      @wrapper.qbfc_method_missing(@sess, :payee_full_name).should == full_name
+    end
+
+    it "should have *_id for *EntityRef" do
+      ref = mock('WIN32OLE.PayeeEntityRef')
+      @ole_object.should_receive(:PayeeEntityRef).and_return(ref)
+
+      list_id = "1"
+      list_id_obj = mock('WIN32OLE.ListID')
+      ref.should_receive(:ListID).and_return(list_id_obj)
+      list_id_obj.should_receive(:GetValue).and_return(list_id)
+      
+      @wrapper.qbfc_method_missing(@sess, :payee_id).should == list_id
+    end
+    
+    it "should create a Base-inherited object from a *EntityRef" do
+      entity_ref = mock('WIN32OLE.PayeeEntityRef')
+      @ole_object.should_receive(:PayeeEntityRef).and_return(entity_ref)
+
+      list_id = "1"
+      list_id_obj = mock('WIN32OLE.ListID')
+      entity_ref.should_receive(:ListID).and_return(list_id_obj)
+      list_id_obj.should_receive(:GetValue).and_return(list_id)
+      
+      entity = mock(QBFC::Entity)
+      
+      QBFC::Entity.should_receive(:find_by_id).with(@sess, list_id).and_return(entity)
+      
+      @wrapper.qbfc_method_missing(@sess, :payee).should == entity
+    end
+    
+    it "should return nil for a *Ref if the ole_method calling *Ref returns nil" do
+      @ole_object.should_receive(:PayeeEntityRef).and_return(nil)      
+      @wrapper.qbfc_method_missing(@sess, :payee).should be_nil
+    end
+    
+    it "should create a Base-inherited object from a *Ref" do
+      account_ref = mock('WIN32OLE.AccountRef')
+      @ole_object.should_receive(:AccountRef).and_return(account_ref)
+
+      list_id = "1"
+      list_id_obj = mock('WIN32OLE.ListID')
+      account_ref.should_receive(:ListID).and_return(list_id_obj)
+      list_id_obj.should_receive(:GetValue).and_return(list_id)
+      
+      account = mock(QBFC::Account)
+      
+      QBFC::Account.should_receive(:find_by_id).with(@sess, list_id).and_return(account)
+      
+      @wrapper.qbfc_method_missing(@sess, :account).should == account    
+    end
+    
+    it "should raise NoMethodError if none of the above apply" do
+      lambda { @wrapper.qbfc_method_missing(@sess, :no_method) }.should raise_error(NoMethodError, 'no_method')
+    end
+  end
+end

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