qbwc 0.0.5 → 0.1.0

data/lib/qbwc/version.rb

@@ -1,3 +1,3 @@
 module QBWC
-  VERSION = "0.0.5"
+  VERSION = "0.1.0"
 end

data/lib/qbwc/worker.rb

@@ -0,0 +1,16 @@
+module QBWC
+  class Worker
+
+    def requests(job)
+      []
+    end
+
+    def should_run?(job)
+      true
+    end
+
+    def handle_response(response, session, job, request, data)
+    end
+
+  end
+end

data/qbwc.gemspec

@@ -5,8 +5,8 @@ require "qbwc/version"
 Gem::Specification.new do |s|
   s.name        = "qbwc"
   s.version     = QBWC::VERSION
-  s.authors     = ["Alex Skryl", "Russell Osborne", "German Garcia"]
-  s.email       = ["rut216@gmail.com", "russell@burningpony.com", "geermc4@gmail.com"]
+  s.authors     = ["Alex Skryl", "Russell Osborne", "German Garcia", "Jason Barnabe"]
+  s.email       = ["rut216@gmail.com", "russell@burningpony.com", "geermc4@gmail.com", "jason.barnabe@gmail.com"]
   s.homepage    = ""
   s.summary     = %q{A Rails interface for Intuit's Quickbooks Web Connector}
   s.description = %q{A Rails interface for Intuit's Quickbooks Web Connector that's OPEN SOURCE!}
@@ -22,12 +22,18 @@ Gem::Specification.new do |s|
     "README.md"
   ]
 
-  s.add_dependency "quickbooks_api", [">= 0.1.6"]
-  s.add_dependency "rubyjedi-soap4r", [">= 1.5.8.20100619003610"]
+  s.add_dependency "qbxml", [">= 0.3.0"]
+  s.add_dependency "wash_out", [">= 0.7.1"]
+
   s.add_development_dependency('guard')
   s.add_development_dependency('guard-rspec')
   s.add_development_dependency('rb-fsevent')
   s.add_development_dependency('webmock')
   s.add_development_dependency('rspec')
-
+  s.add_development_dependency('activerecord')
+  s.add_development_dependency('actionpack')
+  s.add_development_dependency('rails', [">= 4.1.0"])
+  s.add_development_dependency('sqlite3')
+  s.add_development_dependency('minitest')
+  s.add_development_dependency('rake')
 end

data/test/qbwc/controllers/controller_test.rb

@@ -0,0 +1,157 @@
+$:<< File.expand_path(File.dirname(__FILE__) + '/../..')
+require 'test_helper.rb'
+
+# http://pivotallabs.com/writing-rails-engine-rspec-controller-tests/
+# http://jkamenik.github.io/blog/2014/02/07/controller-test-in-rails-engines/
+# https://www.honeybadger.io/blog/2014/01/28/rails4-engine-controller-specs
+class QBWCControllerTest < ActionController::TestCase
+
+  def setup
+    @routes = Rails.application.routes  # https://github.com/blowmage/minitest-rails/issues/133#issuecomment-36401436
+    @controller = QbwcController.new    # http://stackoverflow.com/a/7743176
+
+    @controller.prepend_view_path("#{Gem::Specification.find_by_name("wash_out").gem_dir}/app/views")
+    #p @controller.view_paths
+
+    QBWC.on_error = :stop
+    QBWC::ActiveRecord::Session::QbwcSession.all.each {|qbs| qbs.destroy}
+    QBWC.clear_jobs
+    QBWC.set_session_initializer() {|session| }
+
+    $HANDLE_RESPONSE_EXECUTED = false
+  end
+
+  test "qwc" do
+    #_inspect_routes
+    process(:qwc)
+
+    assert_match /QBWCXML/,                                                 @response.body
+    assert_match Regexp.new("AppName.*QbwcTestApplication #{Rails.env}.*AppName"),       @response.body
+    assert_match /AppURL.*http:\/\/test.host\/qbwc\/action.*AppURL/,        @response.body
+    assert_match /AppDescription.*Quickbooks integration.*AppDescription/,  @response.body
+    assert_match /AppSupport.*https:\/\/test.host\/.*AppSupport/,           @response.body
+    assert_match /UserName.*#{QBWC_USERNAME}.*UserName/,                    @response.body
+  end
+
+  test "authenticate with no jobs" do
+    _authenticate
+    assert_equal 0, QBWC.pending_jobs(COMPANY).count
+    assert @response.body.include?(QBWC::Controller::AUTHENTICATE_NO_WORK), @response.body
+  end
+
+  test "authenticate with jobs" do
+    _authenticate_with_queued_job
+    assert_equal 1, QBWC.pending_jobs(COMPANY).count
+    assert @response.body.include?(COMPANY), @response.body
+  end
+
+  test "authenticate fail" do
+    _authenticate_wrong_password
+    assert @response.body.include?(QBWC::Controller::AUTHENTICATE_NOT_VALID_USER), @response.body
+  end
+
+  test "authenticate with initialization block" do
+     initializer_called = false
+     QBWC.set_session_initializer() do |session|
+        initializer_called = true
+        assert_not_nil session
+        assert_equal QBWC_USERNAME, session.user
+        assert_equal 0, session.progress
+        assert_nil session.error
+        #assert_not_nil session.current_job
+        #assert_not_nil session.pending_jobs
+        #assert_equal 1, session.pending_jobs.count
+     end
+
+    _authenticate_with_queued_job
+    assert initializer_called
+  end
+
+  test "most recent initialization block is executed" do
+     initializer1_called = false
+     initializer2_called = false
+
+     QBWC.set_session_initializer() do |session|
+        initializer1_called = true
+     end
+
+     QBWC.set_session_initializer() do |session|
+        initializer2_called = true
+     end
+
+    _authenticate_with_queued_job
+    assert ! initializer1_called
+    assert   initializer2_called
+  end
+
+  test "send_request" do
+    QBWC.add_job(:customer_add_rq_job, true, COMPANY, QBWC::Worker, QBWC_CUSTOMER_ADD_RQ)
+    _authenticate
+    _simulate_soap_request('send_request', SEND_REQUEST_SOAP_ACTION, SEND_REQUEST_PARAMS)
+  end
+
+  test "receive_response" do
+    _authenticate_with_queued_job
+    _simulate_soap_request('receive_response', RECEIVE_RESPONSE_SOAP_ACTION, RECEIVE_RESPONSE_PARAMS)
+
+    assert_match /tns:receiveResponseXMLResult.*100..tns:receiveResponseXMLResult/, @response.body
+  end
+
+  class CheckErrorValuesWorker < QBWC::Worker
+    def worker_assert_equal(expected_value, value, tag)
+      raise "#{tag} is not correct" if expected_value != value && ! expected_value.blank?
+    end
+
+    def requests(job)
+      {:customer_query_rq => {:full_name => 'Quincy Bob William Carlos'}}
+    end
+
+    def handle_response(response, session, job, request, expected)
+      unless expected.blank?
+        worker_assert_equal(expected[:session_error],           session.error,           "session.error")
+        worker_assert_equal(expected[:session_status_code],     session.status_code,     "session.status_code")
+        worker_assert_equal(expected[:session_status_severity], session.status_severity, "session.status_severity")
+      end
+      $HANDLE_RESPONSE_EXECUTED = true
+    end
+  end
+
+  def _receive_response_error_helper(receive_response_xml_result, schedule_second_job)
+    expected_values = {
+      :session_error           => RECEIVE_RESPONSE_ERROR_PARAMS[:message],
+      :session_status_code     => RECEIVE_RESPONSE_ERROR_PARAMS[:hresult],
+      :session_status_severity => 'Error',
+    }
+
+    QBWC.add_job(:customer_add_rq_job1, true, COMPANY, CheckErrorValuesWorker, nil, expected_values)
+    QBWC.add_job(:customer_add_rq_job2, true, COMPANY, CheckErrorValuesWorker) if schedule_second_job
+
+    _authenticate
+    _simulate_soap_request('receive_response', RECEIVE_RESPONSE_SOAP_ACTION, RECEIVE_RESPONSE_ERROR_PARAMS)
+
+    assert $HANDLE_RESPONSE_EXECUTED  # https://github.com/skryl/qbwc/pull/50#discussion_r23764154
+    assert_match /tns:receiveResponseXMLResult.*#{receive_response_xml_result}..tns:receiveResponseXMLResult/, @response.body
+  end
+
+  test "receive_response error stop" do
+    QBWC.on_error = :stop
+    _receive_response_error_helper(-1, false)
+  end
+
+  test "receive_response error continue" do
+    QBWC.on_error = :continue
+    _receive_response_error_helper(100, false)
+  end
+
+  test "receive_response error stop 2jobs" do
+    QBWC.on_error = :stop
+    _receive_response_error_helper(-1, true)
+  end
+
+  test "receive_response error continue 2jobs" do
+    QBWC.on_error = :continue
+    _receive_response_error_helper(50, true)
+  end
+
+end
+

data/test/qbwc/integration/job_management_test.rb

@@ -0,0 +1,86 @@
+$:<< File.expand_path(File.dirname(__FILE__) + '/../..')
+require 'test_helper.rb'
+
+class JobManagementTest < ActionDispatch::IntegrationTest
+
+  def setup
+    JobManagementTest.app = Rails.application
+    Rails.logger = Logger.new('/dev/null')  # or STDOUT
+    QBWC.clear_jobs
+  end
+
+  test "add_job" do
+    QBWC.add_job(:integration_test, true, '', QBWC::Worker)
+    assert_equal 1, QBWC.jobs.length
+
+    # Overwrite existing job
+    QBWC.add_job(:integration_test, true, 'my-company', QBWC::Worker)
+    assert_equal 1, QBWC.jobs.length
+  end
+
+  test "pending_jobs" do
+    QBWC.add_job(:integration_test, true, 'my-company', QBWC::Worker)
+    assert_equal 1, QBWC.pending_jobs('my-company').length
+    assert_empty QBWC.pending_jobs('another-company')
+  end
+
+  test "pending_jobs_disabled" do
+    QBWC.add_job(:integration_test, false, 'my-company', QBWC::Worker)
+    assert_empty QBWC.pending_jobs('my-company')
+  end
+
+  test "get_job" do
+    QBWC.add_job(:integration_test, true, 'my-company', QBWC::Worker)
+    assert_not_nil QBWC.get_job(:integration_test)
+    assert_nil QBWC.get_job(:doesnt_exist)
+  end
+
+  test "clear_jobs" do
+    QBWC.add_job(:integration_test, true, 'my-company', QBWC::Worker)
+    assert_equal 1, QBWC.jobs.length
+    QBWC.clear_jobs
+    assert_empty QBWC.jobs
+  end
+
+  test "delete_job by name" do
+    jobname = :delete_job
+    QBWC.add_job(jobname, true, 'my-company', QBWC::Worker)
+    assert_not_nil QBWC.get_job(jobname)
+    QBWC.delete_job(jobname)
+    assert_nil QBWC.get_job(jobname)
+
+    # Degenerate case does not crash
+    QBWC.delete_job('')
+  end
+
+  test "delete_job by object" do
+    jobname = :delete_job
+    QBWC.add_job(jobname, true, 'my-company', QBWC::Worker)
+    job = QBWC.get_job(jobname)
+    QBWC.delete_job(job)
+    assert_nil QBWC.get_job(jobname)
+
+    # Degenerate case does not crash
+    QBWC.delete_job(nil)
+  end
+
+  class DeleteJobWorker < QBWC::Worker
+    def requests(job)
+      {:customer_query_rq => {:full_name => 'Quincy Bob William Carlos'}}
+    end
+
+    def handle_response(resp, session, job, request, data)
+      QBWC.delete_job(job.name)
+    end
+  end
+
+  test "job deletes itself after running" do
+    QBWC.add_job(:job_deletes_itself_after_running, true, COMPANY, DeleteJobWorker)
+    assert_equal 1, QBWC.pending_jobs(COMPANY).length
+    session = QBWC::Session.new('foo', COMPANY)
+    assert_not_nil session.next_request
+    simulate_response(session)
+    assert_equal 0, QBWC.pending_jobs(COMPANY).length
+  end
+
+end

data/test/qbwc/integration/request_generation_test.rb

@@ -0,0 +1,340 @@
+$:<< File.expand_path(File.dirname(__FILE__) + '/../..')
+require 'test_helper.rb'
+
+class RequestGenerationTest < ActionDispatch::IntegrationTest
+
+  def setup
+    RequestGenerationTest.app = Rails.application
+    QBWC.clear_jobs
+  end
+
+  test "worker with nothing" do
+    QBWC.add_job(:integration_test, true, '', QBWC::Worker)
+    session = QBWC::Session.new('foo', '')
+    assert_nil session.next_request
+  end
+
+  class NilRequestWorker < QBWC::Worker
+    def requests(job)
+      nil
+    end
+  end
+
+  test "worker with nil" do
+    QBWC.add_job(:integration_test, true, '', NilRequestWorker)
+    session = QBWC::Session.new('foo', '')
+    assert_nil session.next_request
+    simulate_response(session)
+    assert_nil session.next_request
+  end
+
+  class SingleRequestWorker < QBWC::Worker
+    def requests(job)
+      $SINGLE_REQUESTS_INVOKED_COUNT += 1 if $SINGLE_REQUESTS_INVOKED_COUNT.is_a?(Integer)
+      {:customer_query_rq => {:full_name => 'Quincy Bob William Carlos'}}
+    end
+  end
+
+  test "simple request worker" do
+    QBWC.add_job(:integration_test, true, '', SingleRequestWorker)
+    QBWC.jobs.each {|job| assert job.requests_provided_when_job_added == false}
+    session = QBWC::Session.new('foo', '')
+    nr = session.next_request
+    assert_not_nil nr
+    assert_match /FullName.*Quincy Bob William Carlos.*FullName/, nr.request
+    simulate_response(session)
+    assert_nil session.next_request
+  end
+
+  class SingleStringRequestWorker < QBWC::Worker
+    def requests(job)
+      $SINGLE_REQUESTS_INVOKED_COUNT += 1 if $SINGLE_REQUESTS_INVOKED_COUNT.is_a?(Integer)
+      QBWC_CUSTOMER_QUERY_RQ
+    end
+  end
+
+  test "simple string request worker" do
+    QBWC.add_job(:integration_test, true, '', SingleStringRequestWorker)
+    QBWC.jobs.each {|job| assert job.requests_provided_when_job_added == false}
+    session = QBWC::Session.new('foo', '')
+    nr = session.next_request
+    assert_not_nil nr
+    assert_match /FullName.*#{QBWC_USERNAME}.*FullName/, nr.request
+    simulate_response(session)
+    assert_nil session.next_request
+  end
+
+  class MultipleRequestWorker < QBWC::Worker
+    def requests(job)
+      $MULTIPLE_REQUESTS_INVOKED_COUNT += 1 if $MULTIPLE_REQUESTS_INVOKED_COUNT.is_a?(Integer)
+      [
+        {:customer_query_rq => {:full_name => 'Quincy Bob William Carlos'}},
+        {:customer_query_rq => {:full_name => 'Quentin Billy Wyatt Charles'}}
+      ]
+    end
+    def handle_response(response, session, job, request, data)
+      $REQUESTS_FOUND_IN_RESPONSE = request
+    end
+  end
+
+  test "multiple request worker" do
+    $MULTIPLE_REQUESTS_INVOKED_COUNT = 0
+    $REQUESTS_FOUND_IN_RESPONSE = []
+
+    QBWC.add_job(:integration_test, true, '', MultipleRequestWorker)
+    session = QBWC::Session.new('foo', '')
+    assert_not_nil session.next_request
+    simulate_response(session)
+    assert_equal ({:customer_query_rq => {:full_name => 'Quincy Bob William Carlos'}}), $REQUESTS_FOUND_IN_RESPONSE
+
+    assert_not_nil session.next_request
+    simulate_response(session)
+    assert_equal ({:customer_query_rq => {:full_name => 'Quentin Billy Wyatt Charles'}}), $REQUESTS_FOUND_IN_RESPONSE
+
+    assert_nil session.next_request
+
+    assert_equal 1, $MULTIPLE_REQUESTS_INVOKED_COUNT
+
+    # requests should be generated once per session
+    session2 = QBWC::Session.new('foo', '')
+    assert_not_nil session2.next
+    simulate_response(session2)
+    assert_not_nil session2.next
+    simulate_response(session2)
+    assert_nil session2.next
+
+    assert_equal 2, $MULTIPLE_REQUESTS_INVOKED_COUNT
+  end
+
+  class RequestsFromDbWorker < QBWC::Worker
+    $REQUESTS_FROM_DB = [
+        {:customer_query_rq => {:full_name => 'Quincy Bob William Carlos'}},
+        {:customer_query_rq => {:full_name => 'Quentin Billy Wyatt Charles'}},
+        {:customer_query_rq => {:full_name => 'Quigley Brian Wally Colin'}},
+    ]
+
+    def requests(job)
+      $REQUESTS_FROM_DB
+    end
+
+    def handle_response(response, session, job, request, data)
+      $REQUESTS_FROM_DB.shift  # Simulate marking first request as completed
+      job.reset
+    end
+  end
+
+  test 'multiple requests from db' do
+    QBWC.add_job(:integration_test_multiple_requests_from_db, true, '', RequestsFromDbWorker)
+    assert_equal 1, QBWC.jobs.length
+    session = QBWC::Session.new('foo', '')
+
+    req1 = session.next_request
+    assert_not_nil req1
+    assert_match /xml.*FullName.*Quincy Bob William Carlos.*FullName/m, req1.request
+    simulate_response(session)
+
+    req2 = session.next_request
+    assert_not_nil req2
+    assert_match /xml.*FullName.*Quentin Billy Wyatt Charles.*FullName/m, req2.request
+    simulate_response(session)
+
+    req3 = session.next_request
+    assert_not_nil req3
+    assert_match /xml.*FullName.*Quigley Brian Wally Colin.*FullName/m, req3.request
+    simulate_response(session)
+
+    assert_nil session.next_request
+  end
+
+  test 'multiple jobs' do
+    $SINGLE_REQUESTS_INVOKED_COUNT   = 0
+    $MULTIPLE_REQUESTS_INVOKED_COUNT = 0
+
+    QBWC.add_job(:integration_test_1, true, '', SingleRequestWorker)
+    QBWC.add_job(:integration_test_2, true, '', MultipleRequestWorker)
+    assert_equal 2, QBWC.jobs.length
+    session = QBWC::Session.new('foo', '')
+
+    # one request from SingleRequestWorker
+    assert_not_nil session.next_request
+    simulate_response(session)
+
+    # two requests from MultipleRequestWorker
+    assert_not_nil session.next_request
+    simulate_response(session)
+    assert_not_nil session.next_request
+    simulate_response(session)
+    assert_nil session.next_request
+
+    assert_equal 1, $SINGLE_REQUESTS_INVOKED_COUNT
+    assert_equal 1, $MULTIPLE_REQUESTS_INVOKED_COUNT
+  end  
+
+  test 'multiple jobs using different request techniques' do
+    $MULTIPLE_REQUESTS_INVOKED_COUNT = 0
+
+    QBWC.add_job(:integration_test_1, true, '', SingleRequestWorker)
+    QBWC.add_job(:integration_test_2, true, '', MultipleRequestWorker, QBWC_CUSTOMER_ADD_RQ)
+    QBWC.jobs.each {|job| assert job.requests_provided_when_job_added == (job.name == 'integration_test_2')}
+    session = QBWC::Session.new('foo', '')
+
+    # one request from SingleRequestWorker
+    assert_not_nil session.next
+    simulate_response(session)
+
+    # Requests from MultipleRequestWorker are suppressed; instead use one request passed when job added
+    assert_not_nil session.next
+    simulate_response(session)
+    assert_nil session.next
+
+    assert_equal 0, $MULTIPLE_REQUESTS_INVOKED_COUNT
+    QBWC.jobs.each {|job| assert job.requests_provided_when_job_added == (job.name == 'integration_test_2')}
+  end
+
+  # https://github.com/skryl/qbwc/issues/58
+  test 'multiple jobs when first job has no requests' do
+    QBWC.add_job(:test_empty,  true, '', QBWC::Worker, [])
+    QBWC.add_job(:test_income, true, '', QBWC::Worker, [{:account_query_rq => {:active_status => 'All', :account_type => 'Income'}}])
+    session = QBWC::Session.new('foo', '')
+
+    # No requests from :test_empty
+
+    # One request from :test_income
+    assert_not_nil session.next_request
+    simulate_response(session)
+    assert_nil session.next_request
+  end
+
+  class ShouldntRunWorker < QBWC::Worker
+    def requests(job)
+      [
+        {:customer_query_rq => {:full_name => 'Quincy Bob William Carlos'}},
+        {:customer_query_rq => {:full_name => 'Quentin Billy Wyatt Charles'}}
+      ]
+    end
+
+    def should_run?(job)
+      false
+    end
+  end
+
+  test "shouldnt run worker" do
+    QBWC.add_job(:integration_test, true, '', ShouldntRunWorker)
+    session = QBWC::Session.new('foo', '')
+    assert_nil session.next_request
+  end
+
+  $VARIABLE_REQUEST_COUNT = 2
+  class VariableRequestWorker < QBWC::Worker
+    def requests(job)
+      r = []
+      $VARIABLE_REQUEST_COUNT.times do
+        r << {:customer_query_rq => {:full_name => 'Quincy Bob William Carlos'}}
+      end
+      return r
+    end
+  end
+
+  test "variable request worker" do
+    QBWC.add_job(:integration_test, true, '', VariableRequestWorker)
+    session = QBWC::Session.new('foo', '')
+    assert_not_nil session.next_request
+    simulate_response(session)
+    # The number of requests should be fixed after the job starts.
+    $VARIABLE_REQUEST_COUNT = 5
+    assert_not_nil session.next_request
+    simulate_response(session)
+    assert_nil session.next_request
+  end
+
+  class RequestsArgumentSuppressesRequestWorker < QBWC::Worker
+    def requests(job)
+      {:foo => 'bar'}
+    end
+  end
+
+  test "requests argument suppresses request worker" do
+    QBWC.add_job(:integration_test, true, '', RequestsArgumentSuppressesRequestWorker, QBWC_CUSTOMER_ADD_RQ)
+    QBWC.jobs.each {|job| assert job.requests_provided_when_job_added == true}
+    session = QBWC::Session.new('foo', '')
+    request = session.next_request
+    assert_not_nil request
+    assert_match /CustomerAddRq.*\/CustomerAddRq/m, request.request
+    simulate_response(session)
+    assert_nil session.next_request
+
+    assert_match /CustomerAddRq.*\/CustomerAddRq/m, QBWC::ActiveRecord::Job::QbwcJob.first[:requests][0]
+    QBWC.jobs.each {|job| assert job.requests_provided_when_job_added == true}
+  end
+
+  class RequestsArgumentOverridesRequestWorker < QBWC::Worker
+    def requests(job)
+      nil
+    end
+  end
+
+  class SimulatedUserModel
+    attr_accessor :name
+  end
+
+  class RequestsArgumentEstablishesRequestEarlyWorker < QBWC::Worker
+    def requests(job)
+      nil
+    end
+  end
+
+  test "requests argument establishes request early" do
+    usr = SimulatedUserModel.new
+    usr.name = QBWC_USERNAME
+
+    QBWC.add_job(:integration_test, true, '', RequestsArgumentEstablishesRequestEarlyWorker, {:customer_query_rq => {:full_name => QBWC_USERNAME}})
+    QBWC.jobs.each {|job| assert job.requests_provided_when_job_added == true}
+    usr.name = 'bleech'
+
+    session = QBWC::Session.new('foo', '')
+    request = session.next_request
+    assert_match /FullName.#{QBWC_USERNAME}.\/FullName/, request.request
+
+    assert_equal [{:customer_query_rq => {:full_name => QBWC_USERNAME}}], QBWC::ActiveRecord::Job::QbwcJob.first[:requests]
+    QBWC.jobs.each {|job| assert job.requests_provided_when_job_added == true}
+  end
+
+  class RequestsArgumentReturnsMultipleRequestsWorker < QBWC::Worker
+    def requests(job)
+      nil
+    end
+  end
+
+  test "requests argument returns multiple requests" do
+    usr1 = SimulatedUserModel.new
+    usr1.name = QBWC_USERNAME
+
+    usr2 = SimulatedUserModel.new
+    usr2.name = 'usr2 name'
+
+    multiple_requests = [
+      {:customer_query_rq => {:full_name => usr1.name}},
+      {:customer_query_rq => {:full_name => usr2.name}}
+    ]
+    QBWC.add_job(:integration_test, true, '', RequestsArgumentEstablishesRequestEarlyWorker, multiple_requests)
+    QBWC.jobs.each {|job| assert job.requests_provided_when_job_added == true}
+    usr1.name = 'bleech'
+    usr2.name = 'bleech'
+
+    session = QBWC::Session.new('foo', '')
+    request1 = session.next_request
+    assert_match /FullName.#{QBWC_USERNAME}.\/FullName/, request1.request
+    simulate_response(session)
+
+    request2 = session.next_request
+    assert_match /FullName.usr2 name.\/FullName/, request2.request
+    simulate_response(session)
+
+    assert_nil session.next_request
+
+    assert_equal multiple_requests[0], QBWC::ActiveRecord::Job::QbwcJob.first[:requests][0]
+    assert_equal multiple_requests[1], QBWC::ActiveRecord::Job::QbwcJob.first[:requests][1]
+    QBWC.jobs.each {|job| assert job.requests_provided_when_job_added == true}
+  end
+
+end