active_force 0.6.1 → 0.7.0

data/spec/active_force/sobject/table_name_spec.rb

@@ -2,45 +2,24 @@ require 'spec_helper'
 
 describe ActiveForce::SObject do
   describe '#table_name' do
-
     it 'Use the class name adding "__c"' do
-      class Custom < ActiveForce::SObject
-      end
-
       expect(Custom.table_name).to eq('Custom__c')
     end
 
     it 'with standard SObject types it does not add the "__c"' do
-      class Account < ActiveForce::SObject
-      end
-
       expect(Account.table_name).to eq('Account')
     end
 
     it 'can be enforced in the class definition' do
-      class EnforcedTableName < ActiveForce::SObject
-        self.table_name = 'Forced__c'
-      end
-
       expect(EnforcedTableName.table_name).to eq('Forced__c')
     end
 
     context 'with a namespace' do
       it "the namespace is not included" do
-        module Foo
-          class Bar < ActiveForce::SObject
-          end
-        end
-
         expect(Foo::Bar.table_name).to eq('Bar__c')
       end
 
       it 'standard types are inferred correctly' do
-        module Foo
-          class Account < ActiveForce::SObject
-          end
-        end
-
         expect(Foo::Account.table_name).to eq('Account')
       end
     end

data/spec/active_force/sobject_spec.rb

@@ -9,17 +9,26 @@ describe ActiveForce::SObject do
   end
 
   describe ".new" do
-
     it 'should assigns values when are passed by parameters' do
       expect(Whizbang.new({ text: 'some text' }).text).to eq 'some text'
     end
-
   end
 
   describe ".build" do
+    let(:sobject){ Whizbang.build sobject_hash }
 
     it "build a valid sobject from a JSON" do
-      expect(Whizbang.build sobject_hash).to be_an_instance_of Whizbang
+      expect(sobject).to be_an_instance_of Whizbang
+    end
+
+    it "sets the values' types from the sf_type" do
+      expect(sobject.boolean).to be_an_instance_of TrueClass
+      expect(sobject.checkbox).to be_an_instance_of FalseClass
+      expect(sobject.date).to be_an_instance_of Date
+      expect(sobject.datetime).to be_an_instance_of DateTime
+      expect(sobject.percent).to be_an_instance_of Float
+      expect(sobject.text).to be_an_instance_of String
+      expect(sobject.picklist_multiselect).to be_an_instance_of String
     end
   end
 
@@ -61,6 +70,7 @@ describe ActiveForce::SObject do
         class IceCream < ActiveForce::SObject
           field :flavors, as: :multi_picklist
         end
+        sundae.changed_attributes.clear
         sundae.flavors = %w(chocolate vanilla strawberry)
       end
 
@@ -84,53 +94,143 @@ describe ActiveForce::SObject do
   end
 
   describe "CRUD" do
-    subject do
-      Whizbang.new(id: '1')
-    end
+    let(:instance){ Whizbang.new(id: '1') }
 
     describe '#update' do
-      before do
-        expected_args = [
-          Whizbang.table_name,
-          {'Text_Label' => 'some text', 'Boolean_Label' => false, 'Id' => '1'}
-        ]
-        expect(client).to receive(:update!).with(*expected_args).and_return('id')
+
+      context 'with valid attributes' do
+        before do
+          expected_args = [
+            Whizbang.table_name,
+            {'Text_Label' => 'some text', 'Boolean_Label' => false, 'Id' => '1', "Updated_From__c"=>"Rails"}
+          ]
+          expect(client).to receive(:update!).with(*expected_args).and_return('id')
+        end
+
+        it 'delegates to the Client with create! and sets the id' do
+          expect(instance.update( text: 'some text', boolean: false )).to eq(true)
+          expect(instance.text).to eq('some text')
+        end
+      end
+
+      context 'with invalid attributes' do
+        it 'sets the error on the instance' do
+          expect(instance.update( boolean: true )).to eq(false)
+          expect(instance.errors).to be_present
+          expect(instance.errors.full_messages.count).to eq(1)
+          expect(instance.errors.full_messages[0]).to eq("Percent can't be blank")
+        end
+      end
+    end
+
+    describe ".update!" do
+      context 'with valid attributes' do
+        describe 'and without a ClientError' do
+          before do
+            expected_args = [
+              Whizbang.table_name,
+              {'Text_Label' => 'some text', 'Boolean_Label' => false, 'Id' => '1', "Updated_From__c"=>"Rails"}
+            ]
+            expect(client).to receive(:update!).with(*expected_args).and_return('id')
+          end
+          it 'saves successfully' do
+            expect(instance.update!( text: 'some text', boolean: false )).to eq(true)
+            expect(instance.text).to eq('some text')
+          end
+        end
+
+        describe 'and with a ClientError' do
+          let(:faraday_error){ Faraday::Error::ClientError.new('Some String') }
+
+          before{ expect(client).to receive(:update!).and_raise(faraday_error) }
+
+          it 'raises an error' do
+            expect{ instance.update!( text: 'some text', boolean: false ) }.to raise_error(Faraday::Error::ClientError)
+          end
+        end
       end
 
-      it 'delegates to the Client with create!' do
-        expect(subject.update({ text: 'some text', boolean: false })).to be_a Whizbang
+      context 'with invalid attributes' do
+        let(:instance){ Whizbang.new boolean: true }
+
+        it 'raises an error' do
+          expect{ instance.update!( text: 'some text', boolean: true ) }.to raise_error(ActiveForce::RecordInvalid)
+        end
       end
     end
 
     describe '#create' do
-      before do
-        expect(client).to receive(:create!).and_return('id')
+      context 'with valid attributes' do
+        before do
+          expect(client).to receive(:create!).and_return('id')
+        end
+
+        it 'delegates to the Client with create! and sets the id' do
+          expect(instance.create).to be_instance_of(Whizbang)
+          expect(instance.id).to eq('id')
+        end
+      end
+
+
+      context 'with invalid attributes' do
+        let(:instance){ Whizbang.new boolean: true }
+
+        it 'sets the error on the instance' do
+          expect(instance.create).to be_instance_of(Whizbang)
+          expect(instance.id).to eq(nil)
+          expect(instance.errors).to be_present
+          expect(instance.errors.full_messages.count).to eq(1)
+          expect(instance.errors.full_messages[0]).to eq("Percent can't be blank")
+        end
       end
+    end
+
+    describe '#create!' do
+      context 'with valid attributes' do
+        describe 'and without a ClientError' do
+
+          before{ expect(client).to receive(:create!).and_return('id') }
 
-      it 'delegates to the Client with create!' do
-        subject.create
+          it 'saves successfully' do
+            expect(instance.create!).to be_instance_of(Whizbang)
+            expect(instance.id).to eq('id')
+          end
+        end
+
+        describe 'and with a ClientError' do
+          let(:faraday_error){ Faraday::Error::ClientError.new('Some String') }
+
+          before{ expect(client).to receive(:create!).and_raise(faraday_error) }
+
+          it 'raises an error' do
+            expect{ instance.create! }.to raise_error(Faraday::Error::ClientError)
+          end
+        end
       end
 
-      it 'sets the id' do
-        subject.create
-        expect(subject.id).to eq('id')
+      context 'with invalid attributes' do
+        let(:instance){ Whizbang.new boolean: true }
+
+        it 'raises an error' do
+          expect{ instance.create! }.to raise_error(ActiveForce::RecordInvalid)
+        end
       end
     end
 
     describe "#destroy" do
       it "should send client :destroy! with its id" do
         expect(client).to receive(:destroy!).with 'Whizbang__c', '1'
-        subject.destroy
+        instance.destroy
       end
     end
 
     describe 'self.create' do
       before do
-        expect(client).to receive(:create!).with(Whizbang.table_name, 'Text_Label' => 'some text').and_return('id')
+        expect(client).to receive(:create!).with(Whizbang.table_name, 'Text_Label' => 'some text', 'Updated_From__c'=>'Rails').and_return('id')
       end
 
       it 'should create a new instance' do
-        expect(Whizbang.create({ text: 'some text' })).to be_a Whizbang
+        expect(Whizbang.create(text: 'some text')).to be_instance_of(Whizbang)
       end
     end
   end
@@ -151,7 +251,7 @@ describe ActiveForce::SObject do
 
   describe "#find_by" do
     it "should query the client, with the SFDC field names and correctly enclosed values" do
-      expect(client).to receive(:query).with("SELECT #{Whizbang.fields.join ', '} FROM Whizbang__c WHERE Id = 123 AND Text_Label = 'foo' LIMIT 1")
+      expect(client).to receive(:query).with("SELECT #{Whizbang.fields.join ', '} FROM Whizbang__c WHERE (Id = 123) AND (Text_Label = 'foo') LIMIT 1")
       Whizbang.find_by id: 123, text: "foo"
     end
   end
@@ -164,13 +264,11 @@ describe ActiveForce::SObject do
     let(:territory){ Territory.new(id: '1', quota_id: '1') }
 
     before do
-      Territory.belongs_to :quota, model: Quota
-      Territory.field :quota_id, from: 'Quota_Id'
       allow(ActiveForce::SObject).to receive(:sfdc_client).and_return client
     end
 
     it 'clears cached associations' do
-      soql = "SELECT Id, Bar_Id__c FROM Quota__c WHERE Id = '1' LIMIT 1"
+      soql = "SELECT Id, Bar_Id__c FROM Quota__c WHERE (Id = '1') LIMIT 1"
       expect(client).to receive(:query).twice.with soql
       allow(Territory).to receive(:find){ territory }
       territory.quota
@@ -180,7 +278,6 @@ describe ActiveForce::SObject do
     end
 
     it "refreshes the object's attributes" do
-      Territory.field :name, from: 'Name'
       territory.name = 'Walter'
       expect(territory.name).to eq 'Walter'
       territory.reload
@@ -212,4 +309,90 @@ describe ActiveForce::SObject do
       end
     end
   end
+
+  describe 'logger output' do
+    let(:instance){ Whizbang.new }
+
+    before do
+      allow(instance).to receive(:create!).and_raise(Faraday::Error::ClientError.new(double))
+    end
+
+    it 'catches and logs the error' do
+      expect(instance).to receive(:logger_output).and_return(false)
+      instance.save
+    end
+  end
+
+  describe ".save!" do
+    let(:instance){ Whizbang.new }
+
+    context 'with valid attributes' do
+      describe 'and without a ClientError' do
+        before{ expect(client).to receive(:create!).and_return('id') }
+        it 'saves successfully' do
+          expect(instance.save!).to eq(true)
+        end
+      end
+
+      describe 'and with a ClientError' do
+        let(:faraday_error){ Faraday::Error::ClientError.new('Some String') }
+
+        before{ expect(client).to receive(:create!).and_raise(faraday_error) }
+
+        it 'raises an error' do
+          expect{ instance.save! }.to raise_error(Faraday::Error::ClientError)
+        end
+      end
+    end
+
+    context 'with invalid attributes' do
+      let(:instance){ Whizbang.new boolean: true }
+
+      it 'raises an error' do
+        expect{ instance.save! }.to raise_error(ActiveForce::RecordInvalid)
+      end
+    end
+  end
+
+  describe ".save" do
+    let(:instance){ Whizbang.new }
+
+    context 'with valid attributes' do
+      describe 'and without a ClientError' do
+        before{ expect(client).to receive(:create!).and_return('id') }
+        it 'saves successfully' do
+          expect(instance.save).to eq(true)
+        end
+      end
+
+      describe 'and with a ClientError' do
+        let(:faraday_error){ Faraday::Error::ClientError.new('Some String') }
+        before{ expect(client).to receive(:create!).and_raise(faraday_error) }
+        it 'returns false' do
+          expect(instance.save).to eq(false)
+        end
+        it 'sets the error on the instance' do
+          instance.save
+          expect(instance.errors).to be_present
+          expect(instance.errors.full_messages.count).to eq(1)
+          expect(instance.errors.full_messages[0]).to eq('Some String')
+        end
+      end
+    end
+
+    context 'with invalid attributes' do
+      let(:instance){ Whizbang.new boolean: true }
+
+      it 'does not save' do
+        expect(instance.save).to eq(false)
+      end
+
+      it 'sets the error on the instance' do
+        instance.save
+        expect(instance.errors).to be_present
+        expect(instance.errors.full_messages.count).to eq(1)
+        expect(instance.errors.full_messages[0]).to eq("Percent can't be blank")
+      end
+    end
+  end
 end

data/spec/active_force/table_spec.rb

@@ -1,9 +1,7 @@
 require 'spec_helper'
-require 'active_force/table'
 
 describe ActiveForce::Table do
   describe '#table_name' do
-
     let(:table) { ActiveForce::Table }
 
     it 'Use the class name adding "__c"' do
@@ -23,6 +21,5 @@ describe ActiveForce::Table do
         expect(table.new('Foo::Account').name).to eq('Account')
       end
     end
-
   end
 end

data/spec/fixtures/sobject/single_sobject_hash.yml

@@ -6,6 +6,8 @@ Text_Label: 'Hi there!'
 Date_Label: '2010-01-01'
 DateTime_Label: '2011-07-07T00:37:00.000+0000'
 Picklist_Multiselect_Label: 'four;six'
+Percent_Label: 20
+Boolean_Label: true
 
 ParentWhizbang__r:
   Name: 'Parent Whizbang'

data/spec/spec_helper.rb

@@ -2,12 +2,18 @@ require "codeclimate-test-reporter"
 CodeClimate::TestReporter.start
 
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
-require 'restforce'
 require 'active_force'
 Dir["./spec/support/**/*"].sort.each { |f| require f }
 require 'pry'
 
-class Territory < ActiveForce::SObject; end
-class Quota < ActiveForce::SObject
-  field :id, from: 'Bar_Id__c'
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.plural 'quota', 'quotas'
+  inflect.plural 'Quota', 'Quotas'
+  inflect.singular 'quota', 'quota'
+  inflect.singular 'Quota', 'Quota'
+end
+
+RSpec.configure do |config|
+  config.order = :random
+  config.include RestforceFactories
 end

data/spec/support/restforce_factories.rb

@@ -0,0 +1,9 @@
+module RestforceFactories
+  def build_restforce_collection(array)
+    Restforce::Collection.new({ 'records' => array }, nil)
+  end
+
+  def build_restforce_sobject(hash)
+    Restforce::SObject.new(hash)
+  end
+end

data/spec/support/sobjects.rb

@@ -0,0 +1,97 @@
+
+class Comment < ActiveForce::SObject
+  self.table_name = "Comment__c"
+  field :post_id, from: "PostId"
+  field :poster_id, from: 'PosterId__c'
+  field :fancy_post_id, from: 'FancyPostId'
+  field :body
+  belongs_to :post
+end
+class Post < ActiveForce::SObject
+  self.table_name = "Post__c"
+  field :title
+  has_many :comments
+  has_many :impossible_comments, model: Comment, scoped_as: ->{ where('1 = 0') }
+  has_many :reply_comments, model: Comment, scoped_as: ->(post){ where(body: "RE: #{post.title}").order('CreationDate DESC') }
+  has_many :ugly_comments, { model: Comment }
+  has_many :poster_comments, { foreign_key: :poster_id, model: Comment }
+end
+class Territory < ActiveForce::SObject
+  field :quota_id, from: "Quota__c"
+  field :name, from: 'Name'
+  belongs_to :quota
+end
+class PrezClub < ActiveForce::SObject
+  field :quota_id, from: 'QuotaId'
+  belongs_to :quota
+end
+class Quota < ActiveForce::SObject
+  field :id, from: 'Bar_Id__c'
+  has_many :prez_clubs
+  has_many :territories
+end
+class Opportunity < ActiveForce::SObject
+  field :account_id, from: 'AccountId'
+  belongs_to :account
+end
+class Account < ActiveForce::SObject
+  field :owner_id, from: 'OwnerId'
+  has_many :opportunities
+  belongs_to :owner
+end
+class Owner < ActiveForce::SObject
+  has_many :accounts
+end
+class Custom < ActiveForce::SObject; end
+class EnforcedTableName < ActiveForce::SObject
+  self.table_name = 'Forced__c'
+end
+
+module Foo
+  class Bar < ActiveForce::SObject; end
+  class Opportunity < ActiveForce::SObject
+    field :account_id, from: 'AccountId'
+    field :partner_account_id, from: 'Partner_Account_Id__c'
+  end
+  class Account < ActiveForce::SObject
+    has_many :opportunities, model: Foo::Opportunity
+    has_many :partner_opportunities, foreign_key: :partner_account_id, model: Foo::Opportunity
+  end
+  class Lead < ActiveForce::SObject; end
+  class Attachment < ActiveForce::SObject
+    field :lead_id, from: 'Lead_Id__c'
+    field :fancy_lead_id, from: 'LeadId'
+    belongs_to :lead, model: Foo::Lead
+    belongs_to :fancy_lead, model: Foo::Lead, foreign_key: :fancy_lead_id
+  end
+end
+
+module Salesforce
+  class PrezClub < ActiveForce::SObject
+    field :quota_id, from: 'QuotaId'
+  end
+  class Quota < ActiveForce::SObject
+    has_many :prez_clubs, model: PrezClub
+  end
+  class Widget < ActiveForce::SObject
+    self.table_name = 'Tegdiw__c'
+  end
+  class Territory < ActiveForce::SObject
+    field :quota_id, from: "QuotaId"
+    field :widget_id, from: 'WidgetId'
+    belongs_to :quota, model: Salesforce::Quota, foreign_key: :quota_id
+    belongs_to :widget, model: Salesforce::Widget, foreign_key: :widget_id
+  end
+  class User < ActiveForce::SObject
+  end
+  class Opportunity < ActiveForce::SObject
+    field :owner_id, from: 'OwnerId'
+    field :account_id, from: 'AccountId'
+    field :business_partner
+    belongs_to :owner, model: Salesforce::User, foreign_key: :owner_id, relationship_name: 'Owner'
+  end
+  class Account < ActiveForce::SObject
+    field :business_partner
+    has_many :partner_opportunities, model: Opportunity, scoped_as: ->(account){ where(business_partner: account.business_partner).includes(:owner) }
+  end
+end