netsuite 0.3.3 → 0.4.0

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/login_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe NetSuite::Actions::Login do
+  before { savon.mock! }
+  after { savon.unmock! }
+
+  it 'properly executes a login call' do
+    message = {"platformMsgs:passport"=>{"platformCore:email"=>"email", "platformCore:password"=>"password", "platformCore:account"=>"1234", "platformCore:role"=>234}}
+
+    savon.expects(:login).with(:message => message).returns(File.read('spec/support/fixtures/login.xml'))
+
+    result = NetSuite::Actions::Login.call({
+      email: 'email',
+      password: 'password',
+      role: 234
+    })
+
+    expect(result.success?).to eq(true)
+    expect(result.body[:user_id]).to_not be_nil
+  end
+end

data/spec/netsuite/records/cash_refund_spec.rb

@@ -6,7 +6,7 @@ describe NetSuite::Records::CashRefund do
 
   it 'has all the right fields' do
     [
-      :tran_date, :to_be_emailed
+      :tran_date, :to_be_emailed, :memo
     ].each do |field|
       expect(cashrefund).to have_field(field)
     end

data/spec/netsuite/records/cash_sale_item_list_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe NetSuite::Records::CashSaleItemList do
+  let(:list) { NetSuite::Records::CashSaleItemList.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::CashSaleItem.new(
+        :amount => 10
+      )
+    end
+
+    it 'can represent itself as a SOAP record' do
+      record =  {
+        'tranSales:item' => [{
+          'tranSales:amount' => 10
+        }]
+      }
+      expect(list.to_record).to eql(record)
+    end
+  end
+end
+

data/spec/netsuite/records/cash_sale_item_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe NetSuite::Records::CashSaleItem do
+  let(:item) { NetSuite::Records::CashSaleItem.new }
+
+  it 'has all the right fields' do
+    [
+      :amount
+    ].each do |field|
+      expect(item).to have_field(field)
+    end
+  end
+
+  it 'has all the right record refs' do
+    [
+      :item, :klass
+    ].each do |record_ref|
+      expect(item).to have_record_ref(record_ref)
+    end
+  end
+
+end
+

data/spec/netsuite/records/credit_memo_apply_list_spec.rb

@@ -15,14 +15,13 @@ describe NetSuite::Records::CreditMemoApplyList do
     end
 
     it 'can represent itself as a SOAP record' do
-      record = [
-        {
-          'tranCust:apply' => {
-            'tranCust:job' => 'something'
-          }
-        }
-      ]
-      expect(list.to_record).to eql(record)
+      record = {
+        'tranCust:apply' => [{
+          'tranCust:job' => 'something'
+        }]
+      }
+
+      expect(list.to_record.should).to eq(record)
     end
   end
 end

data/spec/netsuite/records/credit_memo_item_list_spec.rb

@@ -15,14 +15,12 @@ describe NetSuite::Records::CreditMemoItemList do
     end
 
     it 'can represent itself as a SOAP record' do
-      record = [
-        {
-          'tranCust:item' => {
-            'tranCust:rate' => 10
-          }
-        }
-      ]
-      expect(list.to_record).to eql(record)
+      record = {
+        'tranCust:item' => [{
+          'tranCust:rate' => 10
+        }]
+      }
+      list.to_record.should eql(record)
     end
   end
 end

data/spec/netsuite/records/customer_payment_apply_list_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe NetSuite::Records::CustomerPaymentApplyList do
+  let(:list) { NetSuite::Records::CustomerPaymentApplyList.new }
+  let(:apply) { NetSuite::Records::CustomerPaymentApply.new }
+
+  it 'can have applies be added to it' do
+    list.applies << apply
+    apply_list = list.applies
+    expect(apply_list).to be_kind_of(Array)
+    expect(apply_list.length).to eql(1)
+    apply_list.each { |i| expect(i).to be_kind_of(NetSuite::Records::CustomerPaymentApply) }
+  end
+
+  describe '#to_record' do
+    it 'can represent itself as a SOAP record' do
+      record = {
+          'tranCust:apply' => [{},{}]
+      }
+      list.applies.concat([apply,apply])
+      expect(list.to_record).to eql(record)
+    end
+  end
+
+end

data/spec/netsuite/records/customer_refund_apply_list_spec.rb

@@ -13,14 +13,12 @@ describe NetSuite::Records::CustomerRefundApplyList do
     end
 
     it 'can represent itself as a SOAP record' do
-      record = [
-        {
-          'tranCust:apply' => {
-            'tranCust:amount' => 10
-          }
-        }
-      ]
-      expect(list.to_record).to eql(record)
+      record = {
+        'tranCust:apply' => [{
+          'tranCust:amount' => 10
+        }]
+      }
+      list.to_record.should eql(record)
     end
   end
 

data/spec/netsuite/records/customer_spec.rb

@@ -5,20 +5,20 @@ describe NetSuite::Records::Customer do
 
   it 'has all the right fields' do
     [
-      :access_role, :account_number, :aging, :alt_email, :alt_name, :alt_phone, :balance, :bill_pay,
+      :account_number, :aging, :alt_email, :alt_name, :alt_phone, :balance, :bill_pay,
       :buying_reason, :buying_time_frame, :campaign_category, :click_stream, :comments, :company_name,
       :consol_aging, :consol_balance, :consol_days_overdue, :consol_deposit_balance, :consol_overdue_balance,
       :consol_unbilled_orders, :contrib_pct, :credit_cards_list, :credit_hold_override, :credit_limit,
-      :currency, :currency_list, :date_created, :days_overdue, :default_address,
+      :currency_list, :date_created, :days_overdue, :default_address,
       :deposit_balance, :download_list, :email, :email_preference, :email_transactions, :end_date, :entity_id,
       :estimated_budget, :fax, :fax_transactions, :first_name, :first_visit, :give_access, :global_subscription_status,
       :group_pricing_list, :home_phone, :image, :is_budget_approved, :is_inactive, :is_person, :item_pricing_list, :keywords,
       :language, :last_modified_date, :last_name, :last_page_visited, :last_visit, :middle_name, :mobile_phone,
-      :opening_balance, :opening_balance_account, :opening_balance_date, :overdue_balance, :parent, :partners_list,
+      :opening_balance, :opening_balance_account, :opening_balance_date, :overdue_balance, :partners_list,
       :password, :password2, :phone, :phonetic_name, :pref_cc_processor,:print_on_check_as,
       :print_transactions, :referrer, :reminder_days, :representing_subsidiary, :require_pwd_change, :resale_number,
-      :sales_group, :sales_readiness, :sales_rep, :sales_team_list, :salutation, :send_email, :ship_complete, :shipping_item,
-      :stage, :start_date, :subscriptions_list, :sync_partner_teams, :tax_exempt, :tax_item, :taxable, :terms,
+      :sales_group, :sales_readiness, :sales_team_list, :salutation, :send_email, :ship_complete, :shipping_item,
+      :stage, :start_date, :subscriptions_list, :sync_partner_teams, :tax_exempt, :tax_item, :taxable, 
       :territory, :third_party_acct, :third_party_country, :third_party_zipcode, :title, :unbilled_orders, :url,
       :vat_reg_number, :visits, :web_lead
     ].each do |field|
@@ -28,7 +28,7 @@ describe NetSuite::Records::Customer do
 
   it 'has the right record_refs' do
     [
-      :custom_form, :entity_status, :partner
+      :access_role, :currency, :custom_form, :entity_status, :partner, :sales_rep, :terms, :parent
     ].each do |record_ref|
       expect(customer).to have_record_ref(record_ref)
     end

data/spec/netsuite/records/employee_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+describe NetSuite::Records::Employee do
+  let(:employee) { NetSuite::Records::Employee.new }
+
+  it 'has all the right fields' do
+    [
+      :account_number, :alien_number, :approval_limit, :bill_pay, :birth_date,
+      :comments, :date_created, :direct_deposit, :eligible_for_commission,
+      :email, :employee_status, :employee_type, :entity_id, :expense_limit,
+      :fax, :first_name, :hire_date, :home_phone, :is_inactive, :is_job_resource,
+      :job_description, :labor_cost, :last_modified_date, :last_name, :middle_name,
+      :mobile_phone, :next_review_date, :office_phone, :pay_frequency, :phone,
+      :phonetic_name, :purchase_order_approval_limit, :purchase_order_approver,
+      :purchase_order_limit, :release_date, :resident_status, :salutation,
+      :social_security_number, :title, :visa_exp_date, :visa_type
+    ].each do |field|
+      expect(employee).to have_field(field)
+    end
+  end
+
+  it 'has all the right record refs' do
+    [
+      :location
+    ].each do |record_ref|
+      expect(employee).to have_record_ref(record_ref)
+    end
+  end
+
+  describe '#roles_list' do
+    it 'can be set from attributes'
+    it 'can be set from a RoleList object'
+  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 Employee instance populated with the data from the response object' do
+        expect(NetSuite::Actions::Get).to receive(:call).with([NetSuite::Records::Employee, { :external_id => 1 }], {}).and_return(response)
+        employee = NetSuite::Records::Employee.get(:external_id => 1)
+        expect(employee).to be_kind_of(NetSuite::Records::Employee)
+      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::Employee, { :external_id => 1 }], {}).and_return(response)
+        expect {
+          NetSuite::Records::Employee.get(:external_id => 1)
+        }.to raise_error(NetSuite::RecordNotFound,
+                         /NetSuite::Records::Employee with OPTIONS=(.*) could not be found/)
+      end
+    end
+  end
+
+  describe '#add' do
+    let(:employee) { NetSuite::Records::Employee.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([employee], {}).
+                                            and_return(response)
+        expect(employee.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([employee], {}).
+                                            and_return(response)
+        expect(employee.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([employee], {}).
+                                               and_return(response)
+        expect(employee.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([employee], {}).
+                                               and_return(response)
+        expect(employee.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::Employee, { :internal_id => 1, :email => 'leland.palmer@example.com' }], {}).and_return(response)
+        employee = NetSuite::Records::Employee.new(:internal_id => 1)
+        expect(employee.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::Employee, { :internal_id => 1, :account_number => 7 }], {}).and_return(response)
+        employee = NetSuite::Records::Employee.new(:internal_id => 1)
+        expect(employee.update(:account_number => 7)).to be_falsey
+      end
+    end
+  end
+
+  describe '#to_record' do
+    let(:employee) { NetSuite::Records::Employee.new(:email => 'bob@example.com') }
+
+    it 'returns a hash of attributes that can be used in a SOAP request' do
+      expect(employee.to_record).to eql({ 'listEmp: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(employee.record_type).to eql('listEmp:Employee')
+    end
+  end
+
+  it 'has the right record_refs' do
+    [
+      :currency, :department, :location, :subsidiary
+    ].each do |record_ref|
+      expect(employee).to have_record_ref(record_ref)
+    end
+  end
+end