netsuite 0.8.5 → 0.8.9

data/spec/netsuite/records/invoice_spec.rb

@@ -41,6 +41,99 @@ describe NetSuite::Records::Invoice do
     end
   end
 
+  it 'has all the right search_only_fields' do
+    [
+      :abbrev, :account_type, :acct_corp_card_exp, :actual_production_end_date,
+      :actual_production_start_date, :actual_ship_date, :alt_sales_amount,
+      :alt_sales_net_amount, :amount, :amount_unbilled,
+      :applied_to_foreign_amount, :applied_to_is_fx_variance,
+      :applied_to_link_amount, :applied_to_link_type, :applied_to_transaction,
+      :applying_foreign_amount, :applying_is_fx_variance, :applying_link_amount,
+      :applying_link_type, :applying_transaction, :auth_code,
+      :auto_calculate_lag, :avs_street_match, :avs_zip_match, :billable,
+      :bill_address, :bill_address1, :bill_address2, :bill_address3,
+      :bill_addressee, :bill_attention, :bill_city, :bill_country,
+      :bill_country_code, :billed_date, :billing_amount, :billing_transaction,
+      :bill_phone, :bill_state, :bill_variance_status, :bill_zip, :bin_number,
+      :bin_number_quantity, :bom_quantity, :build_entire_assembly,
+      :build_variance, :built, :can_have_stackable_promotions, :catch_up_period,
+      :cc_customer_code, :cc_exp_date, :cc_holder_name, :cc_number, :cc_street,
+      :cc_zip_code, :cleared, :closed, :close_date, :cogs_amount,
+      :commission_effective_date, :commit, :component_yield,
+      :confirmation_number, :contribution, :contribution_primary,
+      :cost_component_amount, :cost_component_category, :cost_component_item,
+      :cost_component_quantity, :cost_component_standard_cost, :cost_estimate,
+      :cost_estimate_rate, :cost_estimate_type, :created_by, :credit_amount,
+      :csc_match, :custom_gl, :cust_type, :date_created, :days_open,
+      :days_overdue, :debit_amount, :defer_rev_rec, :deposit_date,
+      :deposit_transaction, :doc_unit, :dr_account, :effective_rate,
+      :entity_status, :est_gross_profit_pct, :exclude_from_rate_request,
+      :expected_close_date, :expected_receipt_date, :expense_category,
+      :expense_date, :firmed, :forecast_type, :fulfilling_transaction,
+      :fx_account, :fx_amount, :fx_cost_estimate, :fx_cost_estimate_rate,
+      :fx_est_gross_profit, :fx_tran_cost_estimate, :fx_vsoe_allocation,
+      :fx_vsoe_amount, :fx_vsoe_price, :gco_availabel_to_charge,
+      :gco_available_to_refund, :gco_avs_street_match, :gco_avs_zip_match,
+      :gco_buyer_account_age, :gco_buyer_ip, :gco_charge_amount,
+      :gco_chargeback_amount, :gco_confirmed_charged_total,
+      :gco_confirmed_refunded_total, :gco_creditcard_number, :gco_csc_match,
+      :gco_financial_state, :gco_fulfillment_state, :gco_order_id,
+      :gco_order_total, :gco_promotion_amount, :gco_promotion_name,
+      :gco_refund_amount, :gco_shipping_total, :gco_state_changed_detail,
+      :gift_cert, :gross_amount, :include_in_forecast, :incoterm,
+      :interco_status, :interco_transaction, :inventory_location,
+      :inventory_subsidiary, :in_vsoe_bundle, :is_allocation, :is_backflush,
+      :is_gco_chargeback, :is_gco_charge_confirmed, :is_gco_payment_guaranteed,
+      :is_gco_refund_confirmed, :is_inside_delivery, :is_inside_pickup,
+      :is_intercompany_adjustment, :is_in_transit_payment, :is_multi_ship_to,
+      :is_reversal, :is_rev_rec_transaction, :is_scrap, :is_ship_address,
+      :is_transfer_price_costing, :is_wip, :item, :item_fulfillment_choice,
+      :item_revision, :landed_cost_per_line, :line, :line_sequence_number,
+      :line_unique_key, :location_auto_assigned, :main_line, :main_name,
+      :manufacturing_routing, :match_bill_to_receipt, :memo_main, :memorized,
+      :merchant_account, :multi_subsidiary, :net_amount, :net_amount_no_tax,
+      :next_bill_date, :no_auto_assign_location, :non_reimbursable,
+      :one_time_total, :options, :order_allocation_strategy, :order_priority,
+      :originator, :overhead_parent_item,
+      :override_installments, :package_count, :paid_amount, :paid_transaction,
+      :partner_contribution, :partner_role, :partner_team_member,
+      :paying_amount, :paying_transaction, :payment_approved,
+      :payment_event_date, :payment_event_hold_reason,
+      :payment_event_purchase_card_used, :payment_event_purchase_data_sent,
+      :payment_event_result, :payment_event_type, :payment_hold,
+      :payment_method, :payment_option, :pay_pal_pending, :pay_pal_status,
+      :pay_pal_tran_id, :payroll_batch, :pn_ref_num, :po_rate, :posting,
+      :price_level, :print, :probability, :projected_amount, :project_task,
+      :purchase_order, :quantity, :quantity_billed, :quantity_committed,
+      :quantity_packed, :quantity_picked, :quantity_rev_committed,
+      :quantity_ship_recv, :quantity_uom, :rate,
+      :realized_gain_posting_transaction, :recur_annually_total,
+      :recur_monthly_total, :recur_quarterly_total, :recur_weekly_total,
+      :ref_number, :requested_date, :rev_commit_status,
+      :rev_committing_transaction, :reversal_date, :reversal_number,
+      :rg_account, :rg_amount, :sales_order, :sales_team_member,
+      :sales_team_role, :scheduling_method, :serial_number, :serial_number_cost,
+      :serial_number_cost_adjustment, :serial_number_quantity, :serial_numbers,
+      :ship_address, :ship_address1, :ship_address2, :ship_address3,
+      :ship_addressee, :ship_attention, :ship_carrier, :ship_city,
+      :ship_complete, :ship_country, :ship_country_code, :ship_group,
+      :ship_phone, :shipping_amount, :ship_recv_status_line, :ship_state,
+      :ship_to, :ship_zip, :signed_amount, :subscription, :subscription_line,
+      :tax_amount, :tax_code, :tax_line, :tax_period, :term_in_months,
+      :terms_of_sale, :title, :to_subsidiary, :tran_est_gross_profit,
+      :tran_fx_est_gross_profit, :transaction_discount, :transaction_line_type,
+      :transaction_number, :transfer_location, :transfer_order_item_line,
+      :transfer_order_quantity_committed, :transfer_order_quantity_packed,
+      :transfer_order_quantity_picked, :transfer_order_quantity_received,
+      :transfer_order_quantity_shipped, :type, :unit, :unit_cost_override,
+      :vend_type, :visible_to_customer, :vsoe_allocation, :vsoe_amount,
+      :vsoe_deferral, :vsoe_delivered, :vsoe_permit_discount, :vsoe_price,
+      :web_site,
+    ].each do |field|
+      expect(NetSuite::Records::Invoice).to have_search_only_field(field)
+    end
+  end
+
   it 'has the right record_refs' do
     [
       :account, :bill_address_list, :job, :custom_form, :department, :entity, :klass, :posting_period, :ship_address_list, :terms,
@@ -329,6 +422,7 @@ describe NetSuite::Records::Invoice do
     before do
       invoice.email   = 'something@example.com'
       invoice.tran_id = '4'
+      invoice.close_date = '2021-08-04' # Search only, excluded
     end
     it 'can represent itself as a SOAP record' do
       record = {

data/spec/netsuite/records/non_inventory_resale_item_spec.rb

@@ -0,0 +1,165 @@
+require 'spec_helper'
+
+describe NetSuite::Records::NonInventoryResaleItem do
+  let(:item) { NetSuite::Records::NonInventoryResaleItem.new }
+
+  it 'has the right fields' do
+    [
+      :available_to_partners, :cost_estimate, :cost_estimate_type, :cost_estimate_units, :country_of_manufacture, :created_date,
+      :display_name, :dont_show_price, :enforce_min_qty_internally, :exclude_from_sitemap,
+      :featured_description, :handling_cost, :handling_cost_units, :include_children, :is_donation_item, :is_fulfillable,
+      :is_gco_compliant, :is_inactive, :is_online, :is_taxable, :item_id, :last_modified_date, :manufacturer, :manufacturer_addr1,
+      :manufacturer_city, :manufacturer_state, :manufacturer_tariff, :manufacturer_tax_id, :manufacturer_zip, :matrix_option_list,
+      :matrix_type, :max_donation_amount, :meta_tag_html, :minimum_quantity, :minimum_quantity_units, :mpn,
+      :mult_manufacture_addr, :nex_tag_category, :no_price_message, :offer_support, :on_special, :out_of_stock_behavior,
+      :out_of_stock_message, :overall_quantity_pricing_type, :page_title, :preference_criterion, :presentation_item_list,
+      :prices_include_tax, :producer, :product_feed_list, :rate, :related_items_description, :sales_description,
+      :schedule_b_code, :schedule_b_number, :schedule_b_quantity, :search_keywords, :ship_individually, :shipping_cost,
+      :shipping_cost_units, :shopping_dot_com_category, :shopzilla_category_id, :show_default_donation_amount,
+      :site_category_list, :sitemap_priority, :soft_descriptor, :specials_description, :stock_description, :store_description,
+      :store_detailed_description, :store_display_name, :translations_list, :upc_code, :url_component, :use_marginal_rates,
+      :vsoe_deferral, :vsoe_delivered, :vsoe_permit_discount, :vsoe_price, :weight, :weight_unit, :weight_units
+    ].each do |field|
+      expect(item).to have_field(field)
+    end
+
+    # TODO there is a probably a more robust way to test this
+    expect(item.custom_field_list.class).to eq(NetSuite::Records::CustomFieldList)
+    expect(item.pricing_matrix.class).to eq(NetSuite::Records::PricingMatrix)
+    expect(item.subsidiary_list.class).to eq(NetSuite::Records::RecordRefList)
+    expect(item.item_vendor_list.class).to eq(NetSuite::Records::ItemVendorList)
+
+  end
+
+  it 'has the right record_refs' do
+    [
+        :billing_schedule, :cost_category, :custom_form, :deferred_revenue_account, :department, :income_account,
+        :issue_product, :item_options_list, :klass, :location, :parent, :pricing_group, :purchase_tax_code,
+        :quantity_pricing_schedule, :rev_rec_schedule, :sale_unit, :sales_tax_code, :ship_package, :store_display_image,
+        :store_display_thumbnail, :store_item_template, :tax_schedule, :units_type, :expense_account
+    ].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 => { :manufacturer_zip => '90401' }) }
+
+      it 'returns a NonInventoryResaleItem instance populated with the data from the response object' do
+        expect(NetSuite::Actions::Get).to receive(:call).with([NetSuite::Records::NonInventoryResaleItem, {:external_id => 20}], {}).and_return(response)
+        customer = NetSuite::Records::NonInventoryResaleItem.get(:external_id => 20)
+        expect(customer).to be_kind_of(NetSuite::Records::NonInventoryResaleItem)
+        expect(customer.manufacturer_zip).to eql('90401')
+      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::NonInventoryResaleItem, {:external_id => 20}], {}).and_return(response)
+        expect {
+          NetSuite::Records::NonInventoryResaleItem.get(:external_id => 20)
+        }.to raise_error(NetSuite::RecordNotFound,
+          /NetSuite::Records::NonInventoryResaleItem with OPTIONS=(.*) could not be found/)
+      end
+    end
+  end
+
+  describe '#add' 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::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 '#update' 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::Update).to receive(:call).
+            with([item.class, {external_id: 'foo'}], {}).
+            and_return(response)
+        item.external_id = 'foo'
+        expect(item.update).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::Update).to receive(:call).
+            with([item.class, {external_id: 'foo'}], {}).
+            and_return(response)
+        item.external_id = 'foo'
+        expect(item.update).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.handling_cost = 100.0
+      item.is_online     = true
+    end
+
+    it 'can represent itself as a SOAP record' do
+      record = {
+        'listAcct:handlingCost' => 100.0,
+        'listAcct:isOnline'     => true
+      }
+      expect(item.to_record).to eql(record)
+    end
+  end
+
+  describe '#record_type' do
+    it 'returns a string of the SOAP type' do
+      expect(item.record_type).to eql('listAcct:NonInventoryResaleItem')
+    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/service_resale_item_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+describe NetSuite::Records::ServiceResaleItem do
+  let(:item) { NetSuite::Records::ServiceResaleItem.new }
+
+  it 'has the right fields' do
+    [
+      :available_to_partners, :cost, :cost_estimate, :cost_estimate_type, :cost_estimate_units, :create_job, :created_date,
+      :display_name, :dont_show_price, :enforce_min_qty_internally, :exclude_from_sitemap, :featured_description,
+      :include_children, :is_donation_item, :is_fulfillable, :is_gco_compliant, :is_inactive, :is_online, :is_taxable,
+      :item_id, :last_modified_date, :matrix_option_list, :matrix_type, :max_donation_amount, :meta_tag_html,
+      :minimum_quantity, :minimum_quantity_units, :no_price_message, :offer_support, :on_special, :out_of_stock_behavior,
+      :out_of_stock_message, :overall_quantity_pricing_type, :page_title, :presentation_item_list, :prices_include_tax,
+      :show_default_donation_amount, :site_category_list, :sitemap_priority, :soft_descriptor, :specials_description,
+      :store_description, :store_detailed_description, :store_display_name, :translations_list, :upc_code, :url_component,
+      :use_marginal_rates, :vsoe_deferral, :vsoe_delivered, :vsoe_permit_discount, :vsoe_price, :vsoe_sop_group
+    ].each do |field|
+      expect(item).to have_field(field)
+    end
+
+    # TODO there is a probably a more robust way to test this
+    expect(item.custom_field_list.class).to eq(NetSuite::Records::CustomFieldList)
+    expect(item.pricing_matrix.class).to eq(NetSuite::Records::PricingMatrix)
+    expect(item.subsidiary_list.class).to eq(NetSuite::Records::RecordRefList)
+  end
+
+  it 'has the right record_refs' do
+    [
+      :billing_schedule, :cost_category, :custom_form, :deferred_revenue_account, :department, :income_account,
+      :issue_product, :item_options_list, :klass, :location, :parent, :pricing_group, :purchase_tax_code,
+      :quantity_pricing_schedule, :rev_rec_schedule, :sale_unit, :sales_tax_code, :store_display_image,
+      :store_display_thumbnail, :store_item_template, :tax_schedule, :units_type
+    ].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 => 'penguins' }) }
+
+      it 'returns a ServiceResaleItem instance populated with the data from the response object' do
+        expect(NetSuite::Actions::Get).to receive(:call).with([NetSuite::Records::ServiceResaleItem, :external_id => 20], {}).and_return(response)
+        customer = NetSuite::Records::ServiceResaleItem.get(:external_id => 20)
+        expect(customer).to be_kind_of(NetSuite::Records::ServiceResaleItem)
+        expect(customer.item_id).to eql('penguins')
+      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::ServiceResaleItem, :external_id => 20], {}).and_return(response)
+        expect {
+          NetSuite::Records::ServiceResaleItem.get(:external_id => 20)
+        }.to raise_error(NetSuite::RecordNotFound,
+          /NetSuite::Records::ServiceResaleItem with OPTIONS=(.*) could not be found/)
+      end
+    end
+  end
+
+  describe '#add' do
+    let(:item) { NetSuite::Records::ServiceResaleItem.new(:cost => 100, :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 = 'penguins'
+      item.is_online     = true
+    end
+
+    it 'can represent itself as a SOAP record' do
+      record = {
+        'listAcct:itemId' => 'penguins',
+        'listAcct:isOnline'     => true
+      }
+      expect(item.to_record).to eql(record)
+    end
+  end
+
+  describe '#record_type' do
+    it 'returns a string of the SOAP type' do
+      expect(item.record_type).to eql('listAcct:ServiceResaleItem')
+    end
+  end
+
+end