netsuite-soap 2025.2.3

data/spec/netsuite/actions/async_update_list_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe NetSuite::Actions::AsyncUpdateList do
+  before { savon.mock! }
+  after { savon.unmock! }
+
+  context 'when record count exceeds the limit' do
+    it 'raises ArgumentError for more than 200 records' do
+      records = Array.new(201) { NetSuite::Records::InventoryItem.new }
+      expect { NetSuite::Actions::AsyncUpdateList.call(records) }.to raise_error(
+        ArgumentError, /asyncUpdateList supports a maximum of 200 records/
+      )
+    end
+  end
+
+  context 'Items' do
+    let(:items) do
+      [
+        NetSuite::Records::InventoryItem.new(internal_id: '624113', item_id: 'Target', upccode: 'Target')
+      ]
+    end
+
+    before do
+      savon.expects(:async_update_list).with(:message =>
+        {
+          'record' => [{
+            'listAcct:itemId' => 'Target',
+            '@xsi:type' => 'listAcct:InventoryItem',
+            '@internalId' => '624113'
+          }]
+        }).returns(fixture('async_update_list/async_update_list_pending.xml'))
+    end
+
+    it 'makes a valid request to the NetSuite API' do
+      NetSuite::Actions::AsyncUpdateList.call(items)
+    end
+
+    it 'returns a valid Response object' do
+      response = NetSuite::Actions::AsyncUpdateList.call(items)
+      expect(response).to be_kind_of(NetSuite::Response)
+      expect(response).to be_success
+      expect(response.body[:job_id]).to eq('ASYNCWEBSERVICES_563214_053120061943428686160042948_4bee0685')
+    end
+  end
+
+  describe 'Support::ClassMethods' do
+    let(:klass) do
+      Class.new do
+        include NetSuite::Actions::AsyncUpdateList::Support
+        def initialize(attrs = {}); end
+      end
+    end
+
+    describe '#async_update_list' do
+      let(:record) { klass.new }
+
+      context 'when the response is successful' do
+        let(:fake_response) { double('response', success?: true, body: { job_id: 'JOB-1' }) }
+
+        before { allow(NetSuite::Actions::AsyncUpdateList).to receive(:call).and_return(fake_response) }
+
+        it 'returns the response body for pre-built instances' do
+          expect(klass.async_update_list([record])).to eq({ job_id: 'JOB-1' })
+        end
+
+        it 'wraps raw attributes as instances using .new' do
+          expect(klass.async_update_list([{ item_id: 'Test' }])).to eq({ job_id: 'JOB-1' })
+        end
+      end
+
+      context 'when the response is unsuccessful' do
+        it 'returns false' do
+          allow(NetSuite::Actions::AsyncUpdateList).to receive(:call)
+            .and_return(double('response', success?: false))
+          expect(klass.async_update_list([record])).to be false
+        end
+      end
+    end
+  end
+end

data/spec/netsuite/actions/async_upsert_list_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+describe NetSuite::Actions::AsyncUpsertList do
+  before { savon.mock! }
+  after { savon.unmock! }
+
+  context 'when record count exceeds the limit' do
+    it 'raises ArgumentError for more than 200 records' do
+      records = Array.new(201) { NetSuite::Records::Customer.new }
+      expect { NetSuite::Actions::AsyncUpsertList.call(records) }.to raise_error(
+        ArgumentError, /asyncUpsertList supports a maximum of 200 records/
+      )
+    end
+  end
+
+  context 'Customers' do
+    context 'one customer' do
+      let(:customers) do
+        [
+          NetSuite::Records::Customer.new(external_id: 'ext2', entity_id: 'Target', company_name: 'Target')
+        ]
+      end
+
+      before do
+        savon.expects(:async_upsert_list).with(:message =>
+          {
+            'record' => [{
+              'listRel:entityId'    => 'Target',
+              'listRel:companyName' => 'Target',
+              '@xsi:type' => 'listRel:Customer',
+              '@externalId' => 'ext2'
+            }]
+          }).returns(fixture('async_upsert_list/async_upsert_list_one_customer.xml'))
+      end
+
+      it 'makes a valid request to the NetSuite API' do
+        NetSuite::Actions::AsyncUpsertList.call(customers)
+      end
+
+      it 'returns a valid Response object' do
+        response = NetSuite::Actions::AsyncUpsertList.call(customers)
+        expect(response).to be_kind_of(NetSuite::Response)
+        expect(response).to be_success
+        expect(response.body[:job_id]).to eq('123')
+      end
+    end
+
+    context 'two customers' do
+      let(:customers) do
+        [
+          NetSuite::Records::Customer.new(external_id: 'ext1', entity_id: 'Shutter Fly', company_name: 'Shutter Fly, Inc.'),
+          NetSuite::Records::Customer.new(external_id: 'ext2', entity_id: 'Target', company_name: 'Target')
+        ]
+      end
+
+      before do
+        savon.expects(:async_upsert_list).with(:message =>
+          {
+            'record' => [{
+                'listRel:entityId'    => 'Shutter Fly',
+                'listRel:companyName' => 'Shutter Fly, Inc.',
+                '@xsi:type' => 'listRel:Customer',
+                '@externalId' => 'ext1'
+              },
+              {
+                'listRel:entityId'    => 'Target',
+                'listRel:companyName' => 'Target',
+                '@xsi:type' => 'listRel:Customer',
+                '@externalId' => 'ext2'
+              }
+            ]
+          }).returns(fixture('async_upsert_list/async_upsert_list_customers.xml'))
+      end
+
+      it 'makes a valid request to the NetSuite API' do
+        NetSuite::Actions::AsyncUpsertList.call(customers)
+      end
+
+      it 'returns a valid Response object' do
+        response = NetSuite::Actions::AsyncUpsertList.call(customers)
+        expect(response).to be_kind_of(NetSuite::Response)
+        expect(response).to be_success
+        expect(response.body[:job_id]).to eq('456')
+      end
+    end
+  end
+
+  describe 'Support::ClassMethods' do
+    let(:klass) do
+      Class.new do
+        include NetSuite::Actions::AsyncUpsertList::Support
+        def initialize(attrs = {}); end
+      end
+    end
+
+    describe '#async_upsert_list' do
+      let(:record) { klass.new }
+
+      context 'when the response is successful' do
+        let(:fake_response) { double('response', success?: true, body: { job_id: 'JOB-1' }) }
+
+        before { allow(NetSuite::Actions::AsyncUpsertList).to receive(:call).and_return(fake_response) }
+
+        it 'returns the response body for pre-built instances' do
+          expect(klass.async_upsert_list([record])).to eq({ job_id: 'JOB-1' })
+        end
+
+        it 'wraps raw attributes as instances using .new' do
+          expect(klass.async_upsert_list([{ entity_id: 'Test' }])).to eq({ job_id: 'JOB-1' })
+        end
+      end
+
+      context 'when the response is unsuccessful' do
+        it 'returns false' do
+          allow(NetSuite::Actions::AsyncUpsertList).to receive(:call)
+            .and_return(double('response', success?: false))
+          expect(klass.async_upsert_list([record])).to be false
+        end
+      end
+    end
+  end
+
+  context 'with errors' do
+    let(:customers) do
+      [
+        NetSuite::Records::Customer.new(external_id: 'ext1-bad', entity_id: 'Shutter Fly', company_name: 'Shutter Fly, Inc.'),
+        NetSuite::Records::Customer.new(external_id: 'ext2-bad', entity_id: 'Target', company_name: 'Target')
+      ]
+    end
+
+    before do
+      savon.expects(:async_upsert_list).with(:message =>
+        {
+          'record' => [{
+            'listRel:entityId'    => 'Shutter Fly',
+            'listRel:companyName' => 'Shutter Fly, Inc.',
+            '@xsi:type' => 'listRel:Customer',
+            '@externalId' => 'ext1-bad'
+          },
+          {
+            'listRel:entityId'    => 'Target',
+            'listRel:companyName' => 'Target',
+            '@xsi:type' => 'listRel:Customer',
+            '@externalId' => 'ext2-bad'
+          }
+          ]
+        }).returns(fixture('async_upsert_list/async_upsert_list_with_errors.xml'))
+    end
+
+    it 'constructs error objects' do
+      response = NetSuite::Actions::AsyncUpsertList.call(customers)
+      expect(response.errors.first.code).to eq('USER_ERROR')
+      expect(response.errors.first.message).to eq('Please enter value(s) for: Item')
+      expect(response.errors.first.type).to eq('ERROR')
+    end
+  end
+end

data/spec/netsuite/actions/attach_file_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe NetSuite::Actions::AttachFile do
+  before(:all) { savon.mock! }
+  after(:all) { savon.unmock! }
+
+  let(:sales_order) { NetSuite::Records::SalesOrder.new(internal_id: 999) }
+  let(:file) {  double('file', internal_id: 111) }
+  let(:message) do
+    {
+      'platformCore:attachReference' => {
+        '@xsi:type' => 'platformCore:AttachBasicReference',
+        'platformCore:attachTo' => {
+          '@internalId' => sales_order.internal_id,
+          '@type' => 'salesOrder',
+          '@xsi:type' => 'platformCore:RecordRef'
+        },
+        'platformCore:attachedRecord' => {
+          '@internalId' => file.internal_id,
+          '@type' => 'file',
+          '@xsi:type' => 'platformCore:RecordRef'
+        }
+      }
+    }
+  end
+
+  before do
+    savon.expects(:attach).with(:message => message).returns(envelope)
+  end
+
+  context 'when successful' do
+    let(:envelope) { File.read('spec/support/fixtures/attach/attach_file_to_sales_order.xml') }
+
+    it 'returns a valid Response object' do
+      response = NetSuite::Actions::AttachFile.call([sales_order, file])
+      expect(response).to be_kind_of(NetSuite::Response)
+      expect(response).to be_success
+    end
+  end
+
+  context 'when not successful' do
+    let(:envelope) { File.read('spec/support/fixtures/attach/attach_file_to_sales_order_error.xml') }
+
+    it 'provides an error method on the object with details about the error' do
+      sales_order.attach_file(file)
+      error = sales_order.errors.first
+
+      expect(error).to be_kind_of(NetSuite::Error)
+      expect(error.type).to eq('ERROR')
+      expect(error.code).to eq('INVALID')
+      expect(error.message).to eq('Invalid request.')
+    end
+
+    it 'provides an error method on the response' do
+      response = NetSuite::Actions::AttachFile.call([sales_order, file])
+      expect(response.errors.first).to be_kind_of(NetSuite::Error)
+    end
+  end
+end

data/spec/netsuite/actions/check_async_status_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe NetSuite::Actions::CheckAsyncStatus do
+  before { savon.mock! }
+  after { savon.unmock! }
+
+  let(:job_id) { 'ASYNCWEBSERVICES_563214_053120061943428686160042948_4bee0685' }
+
+  before do
+    savon.expects(:check_async_status).with(:message =>
+      {
+        'platformMsgs:jobId' => job_id
+      }).returns(fixture('check_async_status/check_async_status_pending.xml'))
+  end
+
+  it 'makes a valid request to the NetSuite API' do
+    NetSuite::Actions::CheckAsyncStatus.call([job_id])
+  end
+
+  it 'returns a valid Response object' do
+    response = NetSuite::Actions::CheckAsyncStatus.call([job_id])
+    expect(response).to be_kind_of(NetSuite::Response)
+    expect(response).to be_success
+    expect(response.body[:job_id]).to be_a(String).and eq(job_id)
+    expect(response.body[:status]).to be_a(String).and eq('pending')
+    expect(response.body[:percent_completed]).to be_a(String).and eq('0.0')
+    expect(response.body[:est_remaining_duration]).to be_a(String).and eq('0.0')
+  end
+end

data/spec/netsuite/actions/delete_list_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe NetSuite::Actions::DeleteList do
+  before(:all) { savon.mock! }
+  after(:all) { savon.unmock! }
+
+  context 'Customer' do
+    let(:klass) { NetSuite::Records::Customer }
+    let(:customer) do
+      NetSuite::Records::Customer.new(:internal_id => '1', :entity_id => 'Customer', :company_name => 'Customer')
+    end
+
+    context 'without errors' do
+      let(:other_customer) do
+        NetSuite::Records::Customer.new(:internal_id => '2', :entity_id => 'Other_Customer', :company_name => 'Other Customer')
+      end
+      let(:customer_list) { [customer.internal_id, other_customer.internal_id] }
+
+      before do
+        savon.expects(:delete_list).with(:message =>
+          {
+            :baseRef =>
+              [
+                {
+                  '@internalId' => customer.internal_id,
+                  '@type'       => 'customer',
+                  '@xsi:type'   => 'platformCore:RecordRef'
+                },
+                {
+                  '@internalId' => other_customer.internal_id,
+                  '@type'       => 'customer',
+                  '@xsi:type'   => 'platformCore:RecordRef'
+                }
+              ]
+          }
+        ).returns(File.read('spec/support/fixtures/delete_list/delete_list_customers.xml'))
+      end
+
+      it 'makes a valid request to the NetSuite API' do
+        NetSuite::Actions::DeleteList.call([klass, :list => customer_list])
+      end
+
+      it 'returns a valid Response object' do
+        response = NetSuite::Actions::DeleteList.call([klass, :list => customer_list])
+
+        expect(response).to be_kind_of(NetSuite::Response)
+        expect(response).to be_success
+      end
+    end
+
+    context 'with errors' do
+      let(:customer_with_error) do
+        NetSuite::Records::Customer.new(:internal_id => 'bad_id', :entity_id => 'Erroneous_Customer', :company_name => 'Erroneous Customer')
+      end
+      let(:customer_list_with_error) { [customer.internal_id, customer_with_error.internal_id] }
+
+      before do
+        savon.expects(:delete_list).with(:message =>
+          {
+            :baseRef =>
+              [
+                {
+                  '@internalId' => customer.internal_id,
+                  '@type'       => 'customer',
+                  '@xsi:type'   => 'platformCore:RecordRef'
+                },
+                {
+                  '@internalId' => customer_with_error.internal_id,
+                  '@type'       => 'customer',
+                  '@xsi:type'   => 'platformCore:RecordRef'
+                }
+              ]
+          }
+        ).returns(File.read('spec/support/fixtures/delete_list/delete_list_customers_with_errors.xml'))
+      end
+
+      it 'constructs error objects' do
+        response = NetSuite::Actions::DeleteList.call([klass, :list => customer_list_with_error])
+        expect(response.errors.keys).to match_array(customer_with_error.internal_id)
+        expect(response.errors[customer_with_error.internal_id].first.code).to eq('USER_EXCEPTION')
+        expect(response.errors[customer_with_error.internal_id].first.message).to eq('Invalid record: type=event,id=100015,scompid=TSTDRV96')
+        expect(response.errors[customer_with_error.internal_id].first.type).to eq('ERROR')
+      end
+    end
+  end
+end

data/spec/netsuite/actions/delete_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe NetSuite::Actions::Delete do
+  before(:all) { savon.mock! }
+  after(:all) { savon.unmock! }
+
+  context 'Customer' do
+    let(:customer) do
+      NetSuite::Records::Customer.new(:internal_id => '980', :entity_id => 'Shutter Fly', :company_name => 'Shutter Fly, Inc.')
+    end
+
+    context 'when successful' do
+      before do
+        savon.expects(:delete).with(:message => {
+          'platformMsgs:baseRef' => {
+            '@internalId' => '980',
+            '@type'       => 'customer',
+            '@xsi:type'   => 'platformCore:RecordRef'
+          },
+        }).returns(File.read('spec/support/fixtures/delete/delete_customer.xml'))
+      end
+
+      it 'makes a valid request to the NetSuite API' do
+        NetSuite::Actions::Delete.call([customer])
+      end
+
+      it 'returns a valid Response object' do
+        response = NetSuite::Actions::Delete.call([customer])
+        expect(response).to be_kind_of(NetSuite::Response)
+        expect(response).to be_success
+      end
+    end
+
+    context 'when not successful' do
+      before do
+        savon.expects(:delete).with(:message => {
+          'platformMsgs:baseRef' => {
+            '@xsi:type' => 'platformCore:RecordRef',
+            '@internalId' => '980',
+            '@type' => 'customer',
+          },
+        }).returns(File.read('spec/support/fixtures/delete/delete_customer_error.xml'))
+      end
+
+      it 'provides an error method on the object with details about the error' do
+        customer.delete
+        error = customer.errors.first
+
+        expect(error).to be_kind_of(NetSuite::Error)
+        expect(error.type).to eq('ERROR')
+        expect(error.code).to eq('INSUFFICIENT_PERMISSION')
+        expect(error.message).to eq("Permission Violation: You need a higher level of the 'Lists -> Documents and Files' permission to access this page. Please contact your account administrator.")
+      end
+
+      it 'provides an error method on the response' do
+        response = NetSuite::Actions::Delete.call([customer])
+        expect(response.errors.first).to be_kind_of(NetSuite::Error)
+      end
+    end
+
+    context 'when not successful with multiple errors' do
+      before do
+        savon.expects(:delete).with(:message => {
+          'platformMsgs:baseRef' => {
+            '@xsi:type' => 'platformCore:RecordRef',
+            '@internalId' => '980',
+            '@type' => 'customer',
+          },
+        }).returns(File.read('spec/support/fixtures/delete/delete_customer_multiple_errors.xml'))
+      end
+
+      it 'provides an error method on the object with details about the error' do
+        customer.delete
+        expect(customer.errors.length).to eq(2)
+
+        error = customer.errors.first
+
+        expect(error).to be_kind_of(NetSuite::Error)
+        expect(error.type).to eq('ERROR')
+        expect(error.code).to eq('INSUFFICIENT_PERMISSION')
+        expect(error.message).to eq("Permission Violation: You need a higher level of the 'Lists -> Documents and Files' permission to access this page. Please contact your account administrator.")
+
+        error = customer.errors[1]
+
+        expect(error).to be_kind_of(NetSuite::Error)
+        expect(error.type).to eq('ERROR')
+        expect(error.code).to eq('SOMETHING_ELSE')
+        expect(error.message).to eq('Another error.')
+      end
+    end
+  end
+
+end

data/spec/netsuite/actions/get_all_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe NetSuite::Actions::GetAll do
+  before { savon.mock! }
+  after  { savon.unmock! }
+
+  let(:currency_class) { NetSuite::Records::Currency }
+
+  describe 'request body' do
+    before do
+      savon.expects(:get_all).with(message: {
+        record: [{ record_type: 'currency' }]
+      }).returns(fixture('get_all/get_all_currencies.xml'))
+    end
+
+    it 'sends the correct record type' do
+      NetSuite::Actions::GetAll.call([currency_class])
+    end
+  end
+
+  describe 'successful response' do
+    before do
+      savon.expects(:get_all).with(message: :any).returns(fixture('get_all/get_all_currencies.xml'))
+    end
+
+    it 'returns a successful Response' do
+      response = NetSuite::Actions::GetAll.call([currency_class])
+      expect(response).to be_kind_of(NetSuite::Response)
+      expect(response).to be_success
+    end
+
+    it 'returns an array of record attribute hashes' do
+      response = NetSuite::Actions::GetAll.call([currency_class])
+      expect(response.body).to be_an(Array)
+      expect(response.body.length).to eq(2)
+    end
+
+    it 'includes record data' do
+      response = NetSuite::Actions::GetAll.call([currency_class])
+      expect(response.body.first[:name]).to eq('US Dollar')
+      expect(response.body.first[:"@internal_id"]).to eq('1')
+      expect(response.body.last[:name]).to eq('Euro')
+      expect(response.body.last[:"@internal_id"]).to eq('2')
+    end
+  end
+
+  describe 'error response' do
+    before do
+      savon.expects(:get_all).with(message: :any).returns(fixture('get_all/get_all_error.xml'))
+    end
+
+    it 'returns an unsuccessful Response' do
+      response = NetSuite::Actions::GetAll.call([currency_class])
+      expect(response).not_to be_success
+    end
+
+    it 'returns nil body' do
+      response = NetSuite::Actions::GetAll.call([currency_class])
+      expect(response.body).to be_nil
+    end
+  end
+
+  describe 'Currency.get_all class method' do
+    context 'when successful' do
+      before do
+        savon.expects(:get_all).with(message: :any).returns(fixture('get_all/get_all_currencies.xml'))
+      end
+
+      it 'returns an array of Currency instances' do
+        currencies = currency_class.get_all
+        expect(currencies).to be_an(Array)
+        expect(currencies.length).to eq(2)
+        expect(currencies).to all(be_kind_of(currency_class))
+      end
+
+      it 'maps record fields onto instances' do
+        currencies = currency_class.get_all
+        expect(currencies.first.name).to eq('US Dollar')
+        expect(currencies.last.name).to eq('Euro')
+      end
+
+      it 'sets internal_id on each instance' do
+        currencies = currency_class.get_all
+        expect(currencies.first.internal_id).to eq('1')
+        expect(currencies.last.internal_id).to eq('2')
+      end
+    end
+
+    context 'when unsuccessful' do
+      before do
+        savon.expects(:get_all).with(message: :any).returns(fixture('get_all/get_all_error.xml'))
+      end
+
+      it 'returns false' do
+        result = currency_class.get_all
+        expect(result).to be false
+      end
+    end
+  end
+end

data/spec/netsuite/actions/get_async_result_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe NetSuite::Actions::GetAsyncResult do
+  before { savon.mock! }
+  after  { savon.unmock! }
+
+  let(:job_id)     { 'ASYNCWEBSERVICES_123456_SB1_000000000000000000000000000_0000000' }
+  let(:page_index) { 1 }
+
+  shared_examples 'a valid GetAsyncResult response' do
+    it 'makes a valid request to the NetSuite API' do
+      NetSuite::Actions::GetAsyncResult.call([job_id, page_index])
+    end
+
+    it 'returns a successful Response' do
+      response = NetSuite::Actions::GetAsyncResult.call([job_id, page_index])
+      expect(response).to be_kind_of(NetSuite::Response)
+      expect(response).to be_success
+    end
+
+    it 'returns the job_id and finished status' do
+      response = NetSuite::Actions::GetAsyncResult.call([job_id, page_index])
+      expect(response.body[:job_id]).to be_a(String).and eq(job_id)
+      expect(response.body[:status]).to be_a(String).and eq('finished')
+    end
+  end
+
+  context 'with a single write response' do
+    before do
+      savon.expects(:get_async_result).with(:message => {
+        'platformMsgs:jobId'     => job_id,
+        'platformMsgs:pageIndex' => page_index
+      }).returns(fixture('get_async_result/get_async_result_upsert_list_finished.xml'))
+    end
+
+    include_examples 'a valid GetAsyncResult response'
+
+    it 'returns a write_response_list with the record ref' do
+      response = NetSuite::Actions::GetAsyncResult.call([job_id, page_index])
+      write_response = response.body[:write_response_list][:write_response]
+
+      expect(write_response[:status][:@is_success]).to be_a(String).and eq('true')
+      expect(write_response[:status][:status_detail][:after_submit_failed]).to be(false)
+
+      base_ref = write_response[:base_ref]
+      expect(base_ref[:@type]).to be_a(String).and eq('cashSale')
+      expect(base_ref[:@external_id]).to be_a(String).and eq('ext1')
+      expect(base_ref[:@internal_id]).to be_a(String).and eq('100001')
+    end
+  end
+
+  context 'with multiple write responses' do
+    let(:job_id) { 'ASYNCWEBSERVICES_123456_SB1_000000000000000000000000000_0000001' }
+
+    before do
+      savon.expects(:get_async_result).with(:message => {
+        'platformMsgs:jobId'     => job_id,
+        'platformMsgs:pageIndex' => page_index
+      }).returns(fixture('get_async_result/get_async_result_write_list_multiple.xml'))
+    end
+
+    include_examples 'a valid GetAsyncResult response'
+
+    it 'returns a write_response_list with all record refs' do
+      response = NetSuite::Actions::GetAsyncResult.call([job_id, page_index])
+      write_responses = response.body[:write_response_list][:write_response]
+
+      expect(write_responses).to be_an(Array)
+      expect(write_responses.length).to eq(2)
+
+      expect(write_responses[0][:base_ref][:@external_id]).to eq('ext1')
+      expect(write_responses[0][:base_ref][:@internal_id]).to eq('100001')
+
+      expect(write_responses[1][:base_ref][:@external_id]).to eq('ext2')
+      expect(write_responses[1][:base_ref][:@internal_id]).to eq('100002')
+    end
+  end
+end