netsuite-soap 2025.2.3

data/spec/netsuite/actions/async_add_list_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe NetSuite::Actions::AsyncAddList do
+  before { savon.mock! }
+  after { savon.unmock! }
+
+  context 'when record count exceeds the limit' do
+    it 'raises ArgumentError for more than 400 records' do
+      records = Array.new(401) { NetSuite::Records::Customer.new }
+      expect { NetSuite::Actions::AsyncAddList.call(records) }.to raise_error(
+        ArgumentError, /asyncAddList supports a maximum of 400 records/
+      )
+    end
+  end
+
+  context 'Customers' do
+    let(:customers) do
+      [
+        NetSuite::Records::Customer.new(external_id: 'ext2', entity_id: 'Target', company_name: 'Target')
+      ]
+    end
+
+    before do
+      savon.expects(:async_add_list).with(:message =>
+        {
+          'record' => [{
+            'listRel:entityId'    => 'Target',
+            'listRel:companyName' => 'Target',
+            '@xsi:type' => 'listRel:Customer',
+            '@externalId' => 'ext2'
+          }]
+        }).returns(fixture('async_add_list/async_add_list_pending.xml'))
+    end
+
+    it 'makes a valid request to the NetSuite API' do
+      NetSuite::Actions::AsyncAddList.call(customers)
+    end
+
+    it 'returns a valid Response object' do
+      response = NetSuite::Actions::AsyncAddList.call(customers)
+      expect(response).to be_kind_of(NetSuite::Response)
+      expect(response).to be_success
+      expect(response.body[:job_id]).to eq('ASYNCWEBSERVICES_563214_053120061943428686160042948_4bee0685')
+      expect(response.body[:status]).to eq('pending')
+    end
+  end
+
+  context 'with internal_id (no external_id)' do
+    let(:customers) do
+      [NetSuite::Records::Customer.new(internal_id: '123', entity_id: 'Foo')]
+    end
+
+    before do
+      savon.expects(:async_add_list).with(:message => {
+        'record' => [{
+          'listRel:entityId' => 'Foo',
+          '@xsi:type'        => 'listRel:Customer',
+          '@internalId'      => '123'
+        }]
+      }).returns(fixture('async_add_list/async_add_list_pending.xml'))
+    end
+
+    it 'includes @internalId in the request' do
+      response = NetSuite::Actions::AsyncAddList.call(customers)
+      expect(response).to be_success
+    end
+  end
+
+  context 'with no internal_id or external_id' do
+    let(:customers) do
+      [NetSuite::Records::Customer.new(entity_id: 'NoId')]
+    end
+
+    before do
+      savon.expects(:async_add_list).with(:message => {
+        'record' => [{
+          'listRel:entityId' => 'NoId',
+          '@xsi:type'        => 'listRel:Customer'
+        }]
+      }).returns(fixture('async_add_list/async_add_list_pending.xml'))
+    end
+
+    it 'omits both @internalId and @externalId' do
+      response = NetSuite::Actions::AsyncAddList.call(customers)
+      expect(response).to be_success
+    end
+  end
+
+  describe 'Support::ClassMethods' do
+    let(:klass) do
+      Class.new do
+        include NetSuite::Actions::AsyncAddList::Support
+        def initialize(attrs = {}); end
+      end
+    end
+
+    describe '#async_add_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::AsyncAddList).to receive(:call).and_return(fake_response) }
+
+        it 'returns the response body for pre-built instances' do
+          expect(klass.async_add_list([record])).to eq({ job_id: 'JOB-1' })
+        end
+
+        it 'wraps raw attributes as instances using .new' do
+          expect(klass.async_add_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::AsyncAddList).to receive(:call)
+            .and_return(double('response', success?: false))
+          expect(klass.async_add_list([record])).to be false
+        end
+      end
+    end
+  end
+end

data/spec/netsuite/actions/async_delete_list_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe NetSuite::Actions::AsyncDeleteList do
+  before { savon.mock! }
+  after { savon.unmock! }
+
+  context 'when record count exceeds the limit' do
+    it 'raises ArgumentError for more than 400 records' do
+      ids = (1..401).map(&:to_s)
+      expect { NetSuite::Actions::AsyncDeleteList.call([NetSuite::Records::Customer, :list => ids]) }.to raise_error(
+        ArgumentError, /asyncDeleteList supports a maximum of 400 records/
+      )
+    end
+  end
+
+  context 'with valid record count' do
+    let(:klass) { NetSuite::Records::Customer }
+    let(:customer) do
+      NetSuite::Records::Customer.new(:internal_id => '1', :entity_id => 'Customer', :company_name => 'Customer')
+    end
+
+    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(:async_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(fixture('async_delete_list/async_delete_list_pending.xml'))
+    end
+
+    it 'makes a valid request to the NetSuite API' do
+      NetSuite::Actions::AsyncDeleteList.call([klass, :list => customer_list])
+    end
+
+    it 'returns a valid Response object' do
+      response = NetSuite::Actions::AsyncDeleteList.call([klass, :list => customer_list])
+
+      expect(response).to be_kind_of(NetSuite::Response)
+      expect(response).to be_success
+      expect(response.body[:status]).to eq('pending')
+    end
+  end
+end

data/spec/netsuite/actions/async_get_list_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe NetSuite::Actions::AsyncGetList do
+  before { savon.mock! }
+  after { savon.unmock! }
+
+  context 'when record count exceeds the limit' do
+    it 'raises ArgumentError for more than 2000 records' do
+      ids = (1..2001).map(&:to_s)
+      expect { NetSuite::Actions::AsyncGetList.call([NetSuite::Records::Customer, :list => ids]) }.to raise_error(
+        ArgumentError, /asyncGetList supports a maximum of 2000 records/
+      )
+    end
+  end
+
+  context 'with valid record count' do
+    let(:klass) { NetSuite::Records::Customer }
+    let(:customer_list) { ['87', '176'] }
+
+    before do
+      savon.expects(:async_get_list).with(:message =>
+        {
+          :baseRef =>
+            [
+              {
+                '@internalId' => '87',
+                '@type'       => 'customer',
+                '@xsi:type'   => 'platformCore:RecordRef'
+              },
+              {
+                '@internalId' => '176',
+                '@type'       => 'customer',
+                '@xsi:type'   => 'platformCore:RecordRef'
+              }
+            ]
+        }
+      ).returns(fixture('async_get_list/async_get_list_pending.xml'))
+    end
+
+    it 'makes a valid request to the NetSuite API' do
+      NetSuite::Actions::AsyncGetList.call([klass, :list => customer_list])
+    end
+
+    it 'returns a valid Response object' do
+      response = NetSuite::Actions::AsyncGetList.call([klass, :list => customer_list])
+
+      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::AsyncGetList::Support
+      end
+    end
+
+    describe '#async_get_list' do
+      context 'when the response is successful' do
+        it 'returns the response body' do
+          fake_response = double('response', success?: true, body: { job_id: 'JOB-1' })
+          allow(NetSuite::Actions::AsyncGetList).to receive(:call).and_return(fake_response)
+          expect(klass.async_get_list(list: ['1', '2'])).to eq({ job_id: 'JOB-1' })
+        end
+      end
+
+      context 'when the response is unsuccessful' do
+        it 'returns false' do
+          allow(NetSuite::Actions::AsyncGetList).to receive(:call)
+            .and_return(double('response', success?: false))
+          expect(klass.async_get_list(list: ['1'])).to be false
+        end
+      end
+    end
+  end
+end

data/spec/netsuite/actions/async_initialize_list_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe NetSuite::Actions::AsyncInitializeList do
+  before { savon.mock! }
+  after { savon.unmock! }
+
+  let(:customer) { NetSuite::Records::Customer.new(:internal_id => 1) }
+
+  context 'SOAP requests' do
+    before do
+      savon.expects(:async_initialize_list).with(:message => {
+        'platformMsgs:initializeRecord' => [
+          {
+            'platformCore:type' => 'customer',
+            'platformCore:reference' => {},
+            :attributes! => {
+              'platformCore:reference' => {
+                'internalId' => 1,
+                :type        => 'customer'
+              }
+            }
+          }
+        ]
+      }).returns(fixture('async_initialize_list/async_initialize_list_pending.xml'))
+    end
+
+    it 'makes a valid request to the NetSuite API' do
+      NetSuite::Actions::AsyncInitializeList.call([
+        { type: NetSuite::Records::Customer, reference: customer }
+      ])
+    end
+
+    it 'returns a valid Response object' do
+      response = NetSuite::Actions::AsyncInitializeList.call([
+        { type: NetSuite::Records::Customer, reference: customer }
+      ])
+      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 '#normalize_entry (private)' do
+    let(:instance) { NetSuite::Actions::AsyncInitializeList.allocate }
+
+    context 'Array entry' do
+      it 'returns [klass, object] unchanged' do
+        entry = [NetSuite::Records::Customer, customer]
+        klass, obj = instance.send(:normalize_entry, entry)
+        expect(klass).to eq(NetSuite::Records::Customer)
+        expect(obj).to eq(customer)
+      end
+    end
+
+    context 'Hash entry with :klass key' do
+      it 'extracts klass from :klass' do
+        entry = { klass: NetSuite::Records::Customer, reference: customer }
+        klass, obj = instance.send(:normalize_entry, entry)
+        expect(klass).to eq(NetSuite::Records::Customer)
+        expect(obj).to eq(customer)
+      end
+    end
+
+    context 'Hash entry with :record_type key' do
+      it 'extracts klass from :record_type' do
+        entry = { record_type: NetSuite::Records::Customer, object: customer }
+        klass, obj = instance.send(:normalize_entry, entry)
+        expect(klass).to eq(NetSuite::Records::Customer)
+        expect(obj).to eq(customer)
+      end
+    end
+
+    context 'invalid entry type' do
+      it 'raises ArgumentError' do
+        expect { instance.send(:normalize_entry, 'invalid') }
+          .to raise_error(ArgumentError, /initialize list entries must be an Array or Hash/)
+      end
+    end
+  end
+
+  describe 'Support::ClassMethods' do
+    let(:klass) do
+      Class.new do
+        include NetSuite::Actions::AsyncInitializeList::Support
+      end
+    end
+
+    describe '#async_initialize_list' do
+      context 'when the response is successful' do
+        it 'returns the response body' do
+          fake_response = double('response', success?: true, body: { job_id: 'JOB-1' })
+          allow(NetSuite::Actions::AsyncInitializeList).to receive(:call).and_return(fake_response)
+          expect(klass.async_initialize_list([])).to eq({ job_id: 'JOB-1' })
+        end
+      end
+
+      context 'when the response is unsuccessful' do
+        it 'returns false' do
+          allow(NetSuite::Actions::AsyncInitializeList).to receive(:call)
+            .and_return(double('response', success?: false))
+          expect(klass.async_initialize_list([])).to be false
+        end
+      end
+    end
+  end
+end

data/spec/netsuite/actions/async_lifecycle_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+# End-to-end test of the async submit → poll → fetch lifecycle.
+# Uses Savon SpecHelper (same pattern as other action specs) and the existing
+# fixture files so no new XML is needed.
+describe 'Async Lifecycle: submit → poll → fetch' do
+  before { savon.mock! }
+  after  { savon.unmock! }
+
+  let(:job_id) { 'ASYNCWEBSERVICES_563214_053120061943428686160042948_4bee0685' }
+  let(:customer) { NetSuite::Records::Customer.new(external_id: 'ext2', entity_id: 'Target', company_name: 'Target') }
+
+  it 'threads job_id through AsyncAddList → CheckAsyncStatus → GetAsyncResult' do
+    # Phase 1: Submit
+    savon.expects(:async_add_list).with(:message => {
+      'record' => [{
+        'listRel:entityId'    => 'Target',
+        'listRel:companyName' => 'Target',
+        '@xsi:type'           => 'listRel:Customer',
+        '@externalId'         => 'ext2'
+      }]
+    }).returns(fixture('async_add_list/async_add_list_pending.xml'))
+
+    submit_response = NetSuite::Actions::AsyncAddList.call([customer])
+    expect(submit_response).to be_success
+    submitted_job_id = submit_response.body[:job_id]
+    expect(submitted_job_id).to be_a(String).and eq(job_id)
+
+    # Phase 2: Poll
+    savon.expects(:check_async_status).with(:message => {
+      'platformMsgs:jobId' => submitted_job_id
+    }).returns(fixture('check_async_status/check_async_status_pending.xml'))
+
+    poll_response = NetSuite::Actions::CheckAsyncStatus.call([submitted_job_id])
+    expect(poll_response).to be_success
+    expect(poll_response.body[:job_id]).to be_a(String).and eq(submitted_job_id)
+    expect(poll_response.body[:status]).to be_a(String).and eq('pending')
+
+    # Phase 3: Fetch result (using the finished fixture)
+    savon.expects(:get_async_result).with(:message => {
+      'platformMsgs:jobId'     => submitted_job_id,
+      'platformMsgs:pageIndex' => 1
+    }).returns(fixture('get_async_result/get_async_result_finished.xml'))
+
+    fetch_response = NetSuite::Actions::GetAsyncResult.call([submitted_job_id, 1])
+    expect(fetch_response).to be_success
+    expect(fetch_response.body[:job_id]).to be_a(String).and eq(submitted_job_id)
+    expect(fetch_response.body[:status]).to be_a(String).and eq('finished')
+    expect(fetch_response.body[:write_response_list]).to be_a(Hash)
+  end
+end

data/spec/netsuite/actions/async_response_spec.rb

@@ -0,0 +1,187 @@
+require 'spec_helper'
+
+describe NetSuite::Actions::AsyncResponse do
+  # Test double that includes the mixin directly.
+  # We set @response manually to simulate what Support::Requests sets after the HTTP call.
+  let(:test_class) do
+    Class.new do
+      include NetSuite::Actions::AsyncResponse
+
+      attr_writer :response
+
+      # Expose private methods under test
+      public :response_hash, :response_body, :success?, :errors
+    end
+  end
+
+  subject(:action) do
+    obj = test_class.new
+    obj.response = double('savon_response', body: body)
+    obj
+  end
+
+  describe '#response_hash' do
+    context 'with nil body' do
+      let(:body) { nil }
+
+      it 'returns nil' do
+        expect(action.response_hash).to be_nil
+      end
+    end
+
+    context 'with empty Hash body' do
+      let(:body) { {} }
+
+      it 'falls back to the body itself' do
+        expect(action.response_hash).to eq({})
+      end
+    end
+
+    context 'with a non-Hash body' do
+      let(:body) { 'error string' }
+
+      it 'returns the body as-is' do
+        expect(action.response_hash).to eq('error string')
+      end
+    end
+
+    context 'when async_response_key is absent from body' do
+      # Default async_response_key is nil, so the unwrap branch is skipped.
+      let(:body) { { async_status_result: { job_id: 'JOB-1', status: 'pending' } } }
+
+      it 'unwraps using async_result_key (:async_status_result)' do
+        expect(action.response_hash).to eq({ job_id: 'JOB-1', status: 'pending' })
+      end
+    end
+
+    context 'when body has no async_result_key' do
+      let(:body) { { some_other_key: 'value' } }
+
+      it 'returns the body unchanged' do
+        expect(action.response_hash).to eq({ some_other_key: 'value' })
+      end
+    end
+
+    context 'with a subclass that overrides async_response_key' do
+      let(:subclass) do
+        Class.new do
+          include NetSuite::Actions::AsyncResponse
+
+          attr_writer :response
+
+          public :response_hash
+
+          private
+
+          def async_response_key
+            :check_async_status_response
+          end
+        end
+      end
+
+      def build_subclass(body)
+        obj = subclass.new
+        obj.response = double('savon_response', body: body)
+        obj
+      end
+
+      context 'when the key is present in body' do
+        let(:inner) { { async_status_result: { job_id: 'JOB-2', status: 'finished' } } }
+        subject(:action) { build_subclass({ check_async_status_response: inner }) }
+
+        it 'unwraps via async_response_key then async_result_key' do
+          expect(action.response_hash).to eq({ job_id: 'JOB-2', status: 'finished' })
+        end
+      end
+
+      context 'when the key is missing from body' do
+        subject(:action) { build_subclass({ other_key: 'data' }) }
+
+        it 'skips unwrap and falls through to async_result_key lookup' do
+          expect(action.response_hash).to eq({ other_key: 'data' })
+        end
+      end
+    end
+  end
+
+  describe '#success?' do
+    context 'with nil body' do
+      let(:body) { nil }
+
+      it 'returns false' do
+        expect(action.success?).to be false
+      end
+    end
+
+    context 'with empty Hash body' do
+      let(:body) { {} }
+
+      it 'returns true (no :@is_success key)' do
+        expect(action.success?).to be true
+      end
+    end
+
+    context 'with status @is_success = "true"' do
+      let(:body) { { status: { :@is_success => 'true' } } }
+
+      it 'returns true' do
+        expect(action.success?).to be true
+      end
+    end
+
+    context 'with status @is_success = "false"' do
+      let(:body) { { status: { :@is_success => 'false' } } }
+
+      it 'returns false' do
+        expect(action.success?).to be false
+      end
+    end
+
+    context 'with status as a non-Hash' do
+      let(:body) { { status: 'not_a_hash' } }
+
+      it 'returns true (status is not a Hash with :@is_success)' do
+        expect(action.success?).to be true
+      end
+    end
+
+    context 'with status Hash but no :@is_success key' do
+      let(:body) { { status: { code: 'OK' } } }
+
+      it 'returns true' do
+        expect(action.success?).to be true
+      end
+    end
+  end
+
+  describe '#errors' do
+    context 'when status_detail is a Hash (single error)' do
+      let(:error_detail) { { code: 'USER_ERROR', message: 'Something went wrong', after_submit_failed: false } }
+      let(:body) { { status: { :@is_success => 'false', status_detail: error_detail } } }
+
+      it 'wraps the Hash in an Array and returns one NetSuite::Error' do
+        result = action.errors
+        expect(result).to be_an(Array)
+        expect(result.length).to eq(1)
+        expect(result.first).to be_kind_of(NetSuite::Error)
+      end
+    end
+
+    context 'when status_detail is an Array (multiple errors)' do
+      let(:error_details) do
+        [
+          { code: 'USER_ERROR', message: 'First error' },
+          { code: 'SYS_ERROR', message: 'Second error' }
+        ]
+      end
+      let(:body) { { status: { :@is_success => 'false', status_detail: error_details } } }
+
+      it 'maps each element to a NetSuite::Error' do
+        result = action.errors
+        expect(result).to be_an(Array)
+        expect(result.length).to eq(2)
+        expect(result).to all(be_kind_of(NetSuite::Error))
+      end
+    end
+  end
+end

data/spec/netsuite/actions/async_search_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe NetSuite::Actions::AsyncSearch do
+  before { savon.mock! }
+  after { savon.unmock! }
+
+  before do
+    savon.expects(:async_search).with(:message => {
+      'searchRecord' => {
+        '@xsi:type'      => 'listRel:CustomerSearchAdvanced',
+        '@savedSearchId' => 500,
+        :content!        => { "listRel:criteria" => {} }
+      },
+    }).returns(fixture('async_search/async_search_pending.xml'))
+  end
+
+  it 'makes a valid request to the NetSuite API' do
+    NetSuite::Actions::AsyncSearch.call([NetSuite::Records::Customer, { saved: 500 }])
+  end
+
+  it 'returns a valid Response object' do
+    response = NetSuite::Actions::AsyncSearch.call([NetSuite::Records::Customer, { saved: 500 }])
+    expect(response).to be_kind_of(NetSuite::Response)
+    expect(response).to be_success
+    expect(response.body[:status]).to eq('pending')
+  end
+end