netsuite-soap 2025.2.3

data/spec/netsuite/records/note_type_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe NetSuite::Records::NoteType do
+  let(:note_type) { NetSuite::Records::NoteType.new }
+
+  it 'has all the right fields' do
+    [
+      :name, :description, :is_inactive
+    ].each do |field|
+      expect(note_type).to have_field(field)
+    end
+  end
+
+  describe '.get' do
+    context 'when the response is successful' do
+      let(:response) { NetSuite::Response.new(:success => true, :body => { :name => 'E-mail', :is_inactive => false }) }
+
+      it 'returns a note_type instance populated with the data from the response object' do
+        expect(NetSuite::Actions::Get).to receive(:call).with([NetSuite::Records::NoteType, {:internal_id => 1}], {}).and_return(response)
+        note_type = NetSuite::Records::NoteType.get(:internal_id => 1)
+        expect(note_type).to be_kind_of(NetSuite::Records::NoteType)
+        expect(note_type.name).to eq 'E-mail'
+        expect(note_type.is_inactive).to be_falsy
+      end
+    end
+
+    context 'when the response is unsuccessful' do
+      let(:response) { NetSuite::Response.new(:success => false, :body => {}) }
+
+      it 'raises a RecordNotFound exception' do
+        expect(NetSuite::Actions::Get).to receive(:call).with([NetSuite::Records::NoteType, {:internal_id => 1}], {}).and_return(response)
+        expect {
+          NetSuite::Records::NoteType.get(:internal_id => 1)
+        }.to raise_error(NetSuite::RecordNotFound,
+          /NetSuite::Records::NoteType with OPTIONS=(.*) could not be found/)
+      end
+    end
+  end
+
+  describe '.search' do
+    context 'when the response is successful' do
+
+      it 'returns a NoteType instance populated with the data from the response object' do
+        body = {
+          total_records: 1,
+          record_list: {
+            record: [
+              {name: 'E-mail', :is_inactive => false },
+            ]
+          }
+        }
+
+        allow(NetSuite::Actions::Search).to receive(:call).with(
+          [NetSuite::Records::NoteType, {:is_inactive => false}], {}
+        ).and_return(
+          NetSuite::Response.new(:success => true, :body => body)
+        )
+
+        search_result = NetSuite::Records::NoteType.search(:is_inactive => false)
+
+        expect(search_result).to be_a NetSuite::Support::SearchResult
+        expect(search_result.total_records).to eq 1
+
+        period1 = search_result.results.first
+
+        expect(period1).to be_a NetSuite::Records::NoteType
+        expect(period1.name).to eq 'E-mail'
+      end
+    end
+  end
+
+  describe '#to_record' do
+    let(:note_type) { NetSuite::Records::NoteType.new(:name => 'E-mail', :is_inactive => false) }
+
+    it 'returns a hash of attributes that can be used in a SOAP request' do
+      expect(note_type.to_record).to eql({
+        'listAcct:name' => 'E-mail',
+        'listAcct:isInactive' => false,
+      })
+    end
+  end
+
+  describe '#record_type' do
+    it 'returns a string type for the record to be used in a SOAP request' do
+      expect(note_type.record_type).to eql('listAcct:NoteType')
+    end
+  end
+end

data/spec/netsuite/records/null_field_list_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe NetSuite::Records::RecordRef do
+  let(:null_field_list) { NetSuite::Records::NullFieldList.new }
+
+  describe '#to_record' do
+    it 'can represent itself as a SOAP record for single value' do
+      null_field_list.name = 'blah'
+      record = {
+        'platformCore:name' => 'blah'
+      }
+      expect(null_field_list.to_record).to eql(record)
+    end
+
+    it 'can represent itself as a SOAP record for multiple values' do
+      null_field_list.name = ['blah', 'foo']
+      record = {
+        'platformCore:name' => ['blah', 'foo']
+      }
+      expect(null_field_list.to_record).to eql(record)
+    end
+  end
+
+  describe '#record_type' do
+    it 'returns a string of the SOAP type' do
+      expect(null_field_list.record_type).to eql('platformCore:NullFieldList')
+    end
+  end
+
+end

data/spec/netsuite/records/partner_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe NetSuite::Records::Partner do
+  let(:partner) { NetSuite::Records::Partner.new }
+
+  it 'has all the right fields' do
+    [
+        :alt_email, :alt_name, :bcn, :comments, :company_name, :date_created, :default_address,
+        :eligible_for_commission, :email, :entity_id, :fax, :first_name, :give_access, :home_phone, :is_inactive,
+        :is_person, :last_modified_date, :last_name, :login_as, :middle_name, :mobile_phone, :partner_code,
+        :password, :password2, :phone, :phonetic_name, :print_on_check_as, :referring_url, :require_pwd_change,
+        :salutation, :send_email, :sub_partner_login, :tax_id_num, :title, :url, :vat_reg_number
+    ].each do |field|
+      expect(partner).to have_field(field)
+    end
+  end
+
+  it 'has all the right record refs' do
+    [
+        :access_role, :klass, :custom_form, :default_tax_reg, :department, :image, :location, :parent, :subsidiary
+    ].each do |record_ref|
+      expect(partner).to have_record_ref(record_ref)
+    end
+  end
+
+  describe '.get' do
+    context 'when the response is successful' do
+      let(:response) { NetSuite::Response.new(:success => true, :body => { :account_number => 7 }) }
+
+      it 'returns an Partner instance populated with the data from the response object' do
+        expect(NetSuite::Actions::Get).to receive(:call).with([NetSuite::Records::Partner, { :external_id => 1 }], {}).and_return(response)
+        Partner = NetSuite::Records::Partner.get(:external_id => 1)
+        expect(Partner).to be_kind_of(NetSuite::Records::Partner)
+      end
+    end
+
+    context 'when the response is unsuccessful' do
+      let(:response) { NetSuite::Response.new(:success => false, :body => {}) }
+
+      it 'raises a RecordNotFound exception' do
+        expect(NetSuite::Actions::Get).to receive(:call).with([NetSuite::Records::Partner, { :external_id => 1 }], {}).and_return(response)
+        expect {
+          NetSuite::Records::Partner.get(:external_id => 1)
+        }.to raise_error(NetSuite::RecordNotFound,
+                         /NetSuite::Records::Partner with OPTIONS=(.*) could not be found/)
+      end
+    end
+  end
+
+  describe '#add' do
+    let(:partner) { NetSuite::Records::Partner.new(:email => 'dale.cooper@example.com') }
+
+    context 'when the response is successful' do
+      let(:response) { NetSuite::Response.new(:success => true, :body => { :internal_id => '1' }) }
+
+      it 'returns true' do
+        expect(NetSuite::Actions::Add).to receive(:call).
+                                            with([partner], {}).
+                                            and_return(response)
+        expect(partner.add).to be_truthy
+      end
+    end
+
+    context 'when the response is unsuccessful' do
+      let(:response) { NetSuite::Response.new(:success => false, :body => {}) }
+
+      it 'returns false' do
+        expect(NetSuite::Actions::Add).to receive(:call).
+                                            with([partner], {}).
+                                            and_return(response)
+        expect(partner.add).to be_falsey
+      end
+    end
+  end
+
+  describe '#delete' do
+    context 'when the response is successful' do
+      let(:response) { NetSuite::Response.new(:success => true, :body => { :internal_id => '1' }) }
+
+      it 'returns true' do
+        expect(NetSuite::Actions::Delete).to receive(:call).
+                                               with([partner], {}).
+                                               and_return(response)
+        expect(partner.delete).to be_truthy
+      end
+    end
+
+    context 'when the response is unsuccessful' do
+      let(:response) { NetSuite::Response.new(:success => false, :body => {}) }
+
+      it 'returns false' do
+        expect(NetSuite::Actions::Delete).to receive(:call).
+                                               with([partner], {}).
+                                               and_return(response)
+        expect(partner.delete).to be_falsey
+      end
+    end
+  end
+
+  describe '.update' do
+    context 'when the response is successful' do
+      let(:response) { NetSuite::Response.new(:success => true, :body => { :email => 'leland.palmer@example.com' }) }
+
+      it 'returns true' do
+        expect(NetSuite::Actions::Update).to receive(:call).with([NetSuite::Records::Partner, { :internal_id => 1, :email => 'leland.palmer@example.com' }], {}).and_return(response)
+        partner = NetSuite::Records::Partner.new(:internal_id => 1)
+        expect(partner.update(:email => 'leland.palmer@example.com')).to be_truthy
+      end
+    end
+
+    context 'when the response is unsuccessful' do
+      let(:response) { NetSuite::Response.new(:success => false, :body => {}) }
+
+      it 'raises a RecordNotFound exception' do
+        expect(NetSuite::Actions::Update).to receive(:call).with([NetSuite::Records::Partner, { :internal_id => 1, :account_number => 7 }], {}).and_return(response)
+        partner = NetSuite::Records::Partner.new(:internal_id => 1)
+        expect(partner.update(:account_number => 7)).to be_falsey
+      end
+    end
+  end
+
+  describe '#to_record' do
+    let(:partner) { NetSuite::Records::Partner.new(:email => 'bob@example.com') }
+
+    it 'returns a hash of attributes that can be used in a SOAP request' do
+      expect(partner.to_record).to eql({ 'listRel:email' => 'bob@example.com' })
+    end
+  end
+
+  describe '#record_type' do
+    it 'returns a string type for the record to be used in a SOAP request' do
+      expect(partner.record_type).to eql('listRel:Partner')
+    end
+  end
+
+  it 'has the right record_refs' do
+    [
+        :klass, :access_role, :department, :subsidiary
+    ].each do |record_ref|
+      expect(partner).to have_record_ref(record_ref)
+    end
+  end
+end

data/spec/netsuite/records/payment_item_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe NetSuite::Records::PaymentItem do
+  let(:item) { NetSuite::Records::PaymentItem.new }
+
+  it 'has all the right fields' do
+    [
+      :available_to_partners, :created_date, :description, :display_name, :include_children, :is_inactive, :item_id, :last_modified_date, :undep_funds
+    ].each do |field|
+      expect(item).to have_field(field)
+    end
+  end
+
+  it 'has all the right record refs' do
+    [
+      :account, :custom_form, :department, :issue_product, :klass, :location, :payment_method
+    ].each do |record_ref|
+      expect(item).to have_record_ref(record_ref)
+    end
+  end
+
+  describe '.get' do
+    context 'when the response is successful' do
+      let(:response) { NetSuite::Response.new(:success => true, :body => { :item_id => "Item100" }) }
+
+      it 'returns a PaymentItem instance populated with the data from the response object' do
+        expect(NetSuite::Actions::Get).to receive(:call).with([NetSuite::Records::PaymentItem, {:external_id => 1}], {}).and_return(response)
+        item = NetSuite::Records::PaymentItem.get(:external_id => 1)
+        expect(item).to be_kind_of(NetSuite::Records::PaymentItem)
+        expect(item.item_id).to eql("Item100")
+      end
+    end
+
+    context 'when the response is unsuccessful' do
+      let(:response) { NetSuite::Response.new(:success => false, :body => {}) }
+
+      it 'raises a RecordNotFound exception' do
+        expect(NetSuite::Actions::Get).to receive(:call).with([NetSuite::Records::PaymentItem, {:external_id => 1}], {}).and_return(response)
+        expect {
+          NetSuite::Records::PaymentItem.get(:external_id => 1)
+        }.to raise_error(NetSuite::RecordNotFound,
+          /NetSuite::Records::PaymentItem with OPTIONS=(.*) could not be found/)
+      end
+    end
+  end
+
+  describe '#add' do
+    let(:item) { NetSuite::Records::PaymentItem.new(:item_id => "Item100", :is_inactive => false) }
+
+    context 'when the response is successful' do
+      let(:response) { NetSuite::Response.new(:success => true, :body => { :internal_id => '1' }) }
+
+      it 'returns true' do
+        expect(NetSuite::Actions::Add).to receive(:call).
+            with([item], {}).
+            and_return(response)
+        expect(item.add).to be_truthy
+      end
+    end
+
+    context 'when the response is unsuccessful' do
+      let(:response) { NetSuite::Response.new(:success => false, :body => {}) }
+
+      it 'returns false' do
+        expect(NetSuite::Actions::Add).to receive(:call).
+            with([item], {}).
+            and_return(response)
+        expect(item.add).to be_falsey
+      end
+    end
+  end
+
+  describe '#delete' do
+    context 'when the response is successful' do
+      let(:response) { NetSuite::Response.new(:success => true, :body => { :internal_id => '1' }) }
+
+      it 'returns true' do
+        expect(NetSuite::Actions::Delete).to receive(:call).
+            with([item], {}).
+            and_return(response)
+        expect(item.delete).to be_truthy
+      end
+    end
+
+    context 'when the response is unsuccessful' do
+      let(:response) { NetSuite::Response.new(:success => false, :body => {}) }
+
+      it 'returns false' do
+        expect(NetSuite::Actions::Delete).to receive(:call).
+            with([item], {}).
+            and_return(response)
+        expect(item.delete).to be_falsey
+      end
+    end
+  end
+
+  describe '#to_record' do
+    before do
+      item.item_id = "Item100"
+      item.is_inactive = false
+    end
+    it 'can represent itself as a SOAP record' do
+      record = {
+        'listAcct:itemId'       => "Item100",
+        'listAcct:isInactive' => false
+      }
+      expect(item.to_record).to eql(record)
+    end
+  end
+
+  describe '#record_type' do
+    it 'returns a string representation of the SOAP type' do
+      expect(item.record_type).to eql('listAcct:PaymentItem')
+    end
+  end
+
+end

data/spec/netsuite/records/payment_method_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe NetSuite::Records::PaymentMethod do
+  let(:payment_method) { NetSuite::Records::PaymentMethod.new }
+
+  it 'has all the right fields' do
+    [
+      :credit_card, :express_checkout_arrangement, :is_debit_card, :is_inactive, :is_online, :name, :pay_pal_email_address,
+      :undep_funds, :use_express_checkout
+    ].each do |field|
+      expect(payment_method).to have_field(field)
+    end
+  end
+
+  it 'has all thr right record refs' do
+    [
+      :account
+    ].each do |record_ref|
+      expect(payment_method).to have_record_ref(record_ref)
+    end
+  end
+
+
+  describe '.get' do
+    context 'when the response is successful' do
+      let(:response) { NetSuite::Response.new(:success => true, :body => { :is_debit_card => true }) }
+
+      it 'returns an PaymentMethod instance populated with the data from the response object' do
+        expect(NetSuite::Actions::Get).to receive(:call).with([NetSuite::Records::PaymentMethod, :external_id => 10], {}).and_return(response)
+        payment_method = NetSuite::Records::PaymentMethod.get(:external_id => 10)
+        expect(payment_method).to be_kind_of(NetSuite::Records::PaymentMethod)
+        expect(payment_method.is_debit_card).to be_truthy
+      end
+    end
+
+    context 'when the response is unsuccessful' do
+      let(:response) { NetSuite::Response.new(:success => false, :body => {}) }
+
+      it 'raises a RecordNotFound exception' do
+        expect(NetSuite::Actions::Get).to receive(:call).with([NetSuite::Records::PaymentMethod, :external_id => 10], {}).and_return(response)
+        expect {
+          NetSuite::Records::PaymentMethod.get(:external_id => 10)
+        }.to raise_error(NetSuite::RecordNotFound,
+          /NetSuite::Records::PaymentMethod with OPTIONS=(.*) could not be found/)
+      end
+    end
+  end
+
+end

data/spec/netsuite/records/phone_call_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe NetSuite::Records::PhoneCall do
+  let(:phone_call) { NetSuite::Records::PhoneCall.new }
+
+  it "has the right fields" do
+    [:title, :message, :phone, :status, :priority, :start_date, :end_date, :completed_date, :timed_event, :access_level].each do |f|
+      expect(phone_call).to have_field(f)
+    end
+  end
+
+  it 'has the right record refs' do
+    [:assigned, :owner, :company, :contact].each do |rr|
+      expect(phone_call).to have_record_ref(rr)
+    end
+  end
+end

data/spec/netsuite/records/pomo_code_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe NetSuite::Records::PromotionCode do
+  let(:promo_code) { NetSuite::Records::PromotionCode.new }
+
+  it 'has all the right fields' do
+    [ :code, :code_pattern, :description, :discount_type, :display_line_discounts, :end_date,
+             :exclude_items, :is_inactive, :is_public, :minimum_order_amount, :name, :number_to_generate,
+             :rate, :start_date
+    ].each do |field|
+      expect(promo_code).to have_field(field)
+    end
+  end
+
+  describe '.get' do
+    context 'when the response is successful' do
+      let(:response) { NetSuite::Response.new(:success => true, :body => { :code => 'SUMMERSALE' }) }
+
+      it 'returns a Campaign instance populated with the data from the response object' do
+        expect(NetSuite::Actions::Get).to receive(:call).with([NetSuite::Records::PromotionCode, {:external_id => 1}], {}).and_return(response)
+        promo_code = NetSuite::Records::PromotionCode.get(:external_id => 1)
+        expect(promo_code).to be_kind_of(NetSuite::Records::PromotionCode)
+        expect(promo_code.code).to eql('SUMMERSALE')
+      end
+    end
+
+    context 'when the response is unsuccessful' do
+      let(:response) { NetSuite::Response.new(:success => false, :body => {}) }
+
+      it 'raises a RecordNotFound exception' do
+        expect(NetSuite::Actions::Get).to receive(:call).with([NetSuite::Records::PromotionCode, {:external_id => 1}], {}).and_return(response)
+        expect {
+          NetSuite::Records::PromotionCode.get(:external_id => 1)
+        }.to raise_error(NetSuite::RecordNotFound,
+          /NetSuite::Records::PromotionCode with OPTIONS=(.*) could not be found/)
+      end
+    end
+  end
+
+end

data/spec/netsuite/records/price_level_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe NetSuite::Records::PriceLevel do
+  describe "#initialize" do
+    it "behaves appropriately if it gets a hash as attributes[:pricing]" do
+      # this is what savon returns if there is only one pricing strategy matrix
+      # for the item:
+      level = {
+        :name => 'Base Price'
+      }
+
+      subject = NetSuite::Records::PriceLevel.new(level)
+      expect(subject.name).to eq(level[:name])
+    end
+  end
+end

data/spec/netsuite/records/pricing_matrix_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe NetSuite::Records::PricingMatrix do
+  describe "#initialize" do
+    it "behaves appropriately if it gets a hash as attributes[:pricing]" do
+      # this is what savon returns if there is only one pricing strategy matrix
+      # for the item:
+      matrix = [
+        {
+          currency: { internal_id: 1 },
+          price_level: { internal_id: 1 },
+          price_list: {
+            price: [
+              {
+                value: 25.0,
+                quantity: 0
+              }
+            ]
+          }
+        }
+      ]
+
+      subject = described_class.new({pricing: matrix})
+      expect(subject.pricing[0]).to be_kind_of(NetSuite::Records::Pricing)
+    end
+  end
+end

data/spec/netsuite/records/record_ref_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe NetSuite::Records::RecordRef do
+  let(:record_ref) { NetSuite::Records::RecordRef.new }
+
+  describe 'internal_id' do
+    context 'when passing in as plain attribute to initialize' do
+      it 'correctly sets the internal_id' do
+        record_ref = NetSuite::Records::RecordRef.new(:internal_id => '1')
+        expect(record_ref.internal_id).to eql('1')
+      end
+    end
+
+    context 'when passing in as swirly attributes to initialize' do
+      it 'correctly sets the internal_id' do
+        record_ref = NetSuite::Records::RecordRef.new(:@internal_id => '2')
+        expect(record_ref.internal_id).to eql('2')
+      end
+    end
+
+    context 'when not passed in as an attribute to initialize' do
+      it 'does not set an internal_id' do
+        record_ref = NetSuite::Records::RecordRef.new
+        expect(record_ref.internal_id).to be_nil
+      end
+    end
+
+    it 'has no public internal_id setter' do
+      expect(record_ref).not_to respond_to(:internal_id=)
+    end
+  end
+
+  describe 'attributes' do
+    let(:record_ref) do
+      NetSuite::Records::RecordRef.new(
+        :name   => 'This is a record_ref',
+        :banana => 'for monkeys'
+      )
+    end
+
+    context 'readers' do
+      it 'can take on arbitrary attributes into itself on initialization' do
+        expect(record_ref.name).to eql('This is a record_ref')
+        expect(record_ref.banana).to eql('for monkeys')
+      end
+    end
+  end
+
+  describe 'untouchables' do
+    let(:record_ref) do
+      NetSuite::Records::RecordRef.new(
+        :"@xmlns:platform_core" => 'something'
+      )
+    end
+
+    it 'ignores untouchable attributes' do
+      expect(record_ref.instance_variable_get('@attributes').keys).not_to include(:"@xmlns:platform_core")
+    end
+  end
+
+  describe 'initialize from record' do
+    it 'initializes a new ref with the proper attributes from the record' do
+      record = NetSuite::Records::Classification.new(:is_inactive => false, :name => 'Retail', :internal_id => '9')
+      record_ref = NetSuite::Records::RecordRef.new(record)
+      expect(record_ref).to be_kind_of(NetSuite::Records::RecordRef)
+      expect(record_ref.internal_id).to eql('9')
+      expect(record_ref.type).to eql('classification')
+    end
+  end
+
+  describe '#to_record' do
+    it 'can represent itself as a SOAP record' do
+      record_ref = NetSuite::Records::RecordRef.new(:something => 'blah')
+      record = {
+        'platformCore:something' => 'blah'
+      }
+      expect(record_ref.to_record).to eql(record)
+    end
+  end
+
+  describe '#record_type' do
+    it 'returns a string of the SOAP type' do
+      expect(record_ref.record_type).to eql('platformCore:RecordRef')
+    end
+  end
+
+end

data/spec/netsuite/records/return_authorization_item_list_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe NetSuite::Records::ReturnAuthorizationItemList do
+  let(:list) { NetSuite::Records::ReturnAuthorizationItemList.new }
+
+  it 'has a items attribute' do
+    expect(list.items).to be_kind_of(Array)
+  end
+
+  describe '#to_record' do
+    before do
+      list.items << NetSuite::Records::ReturnAuthorizationItem.new(
+        :rate => 10
+      )
+    end
+
+    it 'can represent itself as a SOAP record' do
+      record =  {
+        'tranCust:item' => [{
+          'tranCust:rate' => 10
+        }]
+      }
+      expect(list.to_record).to eql(record)
+    end
+  end
+end

data/spec/netsuite/records/return_authorization_item_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe NetSuite::Records::ReturnAuthorizationItem do
+  let(:item) { NetSuite::Records::ReturnAuthorizationItem.new }
+
+  it 'has all the right fields' do
+    [
+      :alt_sales_amt, :amortization_period, :amortization_type, :amount, :bill_variance_status, :catch_up_period, :cost_estimate,
+      :cost_estimate_rate, :cost_estimate_type, :days_before_expiration, :defer_rev_rec, :description, :gift_cert_from, :gift_cert_message,
+      :gift_cert_recipient_email, :gift_cert_recipient_name, :id, :inventory_detail, :is_closed, :is_drop_shipment, :is_taxable,
+      :is_vsoe_bundle, :item_subtype, :item_type, :line, :line_number, :matrix_type, :options, :order_line, :print_items,
+      :quantity, :quantity_billed, :quantity_received, :quantity_rev_committed, :rate, :rate_schedule, :rev_rec_end_date,
+      :rev_rec_start_date, :tax_rate1, :vsoe_allocation, :vsoe_amount, :vsoe_deferral, :vsoe_delivered, :vsoe_is_estimate,
+      :vsoe_permit_discount, :vsoe_price, :vsoe_sop_group
+    ].each do |field|
+      expect(item).to have_field(field)
+    end
+  end
+
+  it 'has all the right record refs' do
+    [
+      :department, :item, :job, :klass, :location, :price, :rev_rec_schedule, :tax_code, :units
+    ].each do |record_ref|
+      expect(item).to have_record_ref(record_ref)
+    end
+  end
+
+
+
+
+end