active_force 0.6.1 → 0.7.0

data/spec/active_force/attribute_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe ActiveForce::Attribute do
+  let(:attribute) { ActiveForce::Attribute }
+
+  describe 'initialize' do
+    let(:some_field) { attribute.new(:some_field) }
+
+    it 'should set "from" and "as" as default' do
+      expect(some_field.sfdc_name).to eq 'Some_Field__c'
+      expect(some_field.as).to eq :string
+    end
+
+    it 'should take values from the option parameter' do
+      other_field = attribute.new(:other_field, sfdc_name: 'OT__c', as: :integer)
+      expect(other_field.sfdc_name).to eq 'OT__c'
+      expect(other_field.as).to eq :integer
+    end
+  end
+
+  describe 'when the attribute is' do
+    it 'a multipick should return all values as 1 string separated with ";"' do
+      names = attribute.new(:names, as: :multi_picklist)
+      expect(names.value_for_hash ['olvap', 'eloy']).to eq 'olvap;eloy'
+    end
+  end
+end

data/spec/active_force/callbacks_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'active_force/sobject'
 
 describe ActiveForce::SObject do
   let(:client) { double 'Client', create!: 'id' }
@@ -9,29 +8,8 @@ describe ActiveForce::SObject do
   end
 
   describe "save" do
-
     it 'call action callback when save a record' do
-      class Whizbanged < ActiveForce::SObject
-
-        field :updated_from
-        field :dirty_attribute
-
-        before_save :set_as_updated_from_rails
-        after_save :mark_dirty
-
-        private
-
-        def set_as_updated_from_rails
-          self.updated_from = 'Rails'
-        end
-
-        def mark_dirty
-          self.dirty_attribute = true
-        end
-
-      end
-
-      whizbanged = Whizbanged.new
+      whizbanged = Whizbang.new
       whizbanged.save
       expect(whizbanged.updated_from).to eq 'Rails'
       expect(whizbanged.dirty_attribute).to eq true

data/spec/active_force/mapping_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe ActiveForce::Mapping do
+  let(:mapping){ ActiveForce::Mapping.new 'some_table' }
+
+  describe 'field' do
+    it 'should add a new attribute to the instance' do
+      mapping.field :id, from: 'Id'
+      expect(mapping.mappings).to eq({ id: 'Id' })
+    end
+
+    it 'sf_names should return all attributes names from salesforce' do
+      mapping.field :id, from: 'Id'
+      mapping.field :name, from: 'Name'
+      expect(mapping.sfdc_names).to eq ['Id', 'Name']
+    end
+  end
+end

data/spec/active_force/query_spec.rb

@@ -1,148 +1,126 @@
 require 'spec_helper'
-require 'active_force/query'
 
 describe ActiveForce::Query do
-
-  before do
-    @query = ActiveForce::Query.new 'table_name'
-    @query.fields ['name', 'etc']
-  end
-
-  after do
+  let(:query) do
+    query = ActiveForce::Query.new 'table_name'
+    query.fields ['name', 'etc']
+    query
   end
 
   describe '.select' do
     it 'use column sent on the select method' do
-      expect(@query.select('name').all.to_s).to eq "SELECT name FROM table_name"
+      expect(query.select('name').all.to_s).to eq "SELECT name FROM table_name"
     end
 
     it 'use columns sent on the select method' do
-      expect(@query.select(['id','name']).all.to_s).to eq "SELECT id, name FROM table_name"
+      expect(query.select(['id','name']).all.to_s).to eq "SELECT id, name FROM table_name"
     end
   end
 
   describe ".all" do
     it "table should return table name" do
-      expect(@query.all.table).to eq(@query.table)
+      expect(query.all.table).to eq(query.table)
     end
 
     it "fields should return fields" do
-      expect(@query.all.fields).to eq @query.fields
+      expect(query.all.fields).to eq query.fields
     end
   end
 
   describe ".all.to_s" do
     it "should return a query for all records" do
-      expect(@query.all.to_s).to eq "SELECT Id, name, etc FROM table_name"
+      expect(query.all.to_s).to eq "SELECT Id, name, etc FROM table_name"
     end
 
     it "should ignore dupicated attributes in select statment" do
-      @query.fields ['Id', 'name', 'etc']
-      expect(@query.all.to_s).to eq "SELECT Id, name, etc FROM table_name"
+      query.fields ['Id', 'name', 'etc']
+      expect(query.all.to_s).to eq "SELECT Id, name, etc FROM table_name"
     end
   end
 
   describe ".where" do
     it "should add a where condition to a query" do
-      expect(@query.where("name like '%a%'").to_s).to eq "SELECT Id, name, etc FROM table_name WHERE name like '%a%'"
+      expect(query.where("name like '%a%'").to_s).to eq "SELECT Id, name, etc FROM table_name WHERE (name like '%a%')"
     end
 
-    it "should add multiples conditions to a query" do
-      expect(@query.where("condition1 = 1").where("condition2 = 2").to_s).to eq "SELECT Id, name, etc FROM table_name WHERE condition1 = 1 AND condition2 = 2"
+    it "should add multiples conditions to a query with parentheses" do
+      expect(query.where("condition1 = 1").where("condition2 = 2 OR condition3 = 3").to_s).to eq "SELECT Id, name, etc FROM table_name WHERE (condition1 = 1) AND (condition2 = 2 OR condition3 = 3)"
     end
   end
 
   describe ".limit" do
     it "should add a limit to a query" do
-      expect(@query.limit("25").to_s).to eq "SELECT Id, name, etc FROM table_name LIMIT 25"
+      expect(query.limit("25").to_s).to eq "SELECT Id, name, etc FROM table_name LIMIT 25"
     end
   end
 
   describe ".limit_value" do
     it "should return the limit value" do
-      @query.limit(4)
-      expect(@query.limit_value).to eq 4
+      query.limit(4)
+      expect(query.limit_value).to eq 4
     end
   end
 
   describe ".offset" do
     it "should add an offset to a query" do
-      expect(@query.offset(4).to_s).to eq "SELECT Id, name, etc FROM table_name OFFSET 4"
+      expect(query.offset(4).to_s).to eq "SELECT Id, name, etc FROM table_name OFFSET 4"
     end
   end
 
   describe ".offset_value" do
     it "should return the offset value" do
-      @query.offset(4)
-      expect(@query.offset_value).to eq 4
+      query.offset(4)
+      expect(query.offset_value).to eq 4
     end
   end
 
   describe ".find.to_s" do
     it "should return a query for 1 record" do
-      expect(@query.find(2).to_s).to eq "SELECT Id, name, etc FROM table_name WHERE Id = '2' LIMIT 1"
+      expect(query.find(2).to_s).to eq "SELECT Id, name, etc FROM table_name WHERE (Id = '2') LIMIT 1"
     end
   end
 
   describe ".order" do
     it "should add a order condition in the statment" do
-      expect(@query.order("name desc").to_s).to eq "SELECT Id, name, etc FROM table_name ORDER BY name desc"
+      expect(query.order("name desc").to_s).to eq "SELECT Id, name, etc FROM table_name ORDER BY name desc"
     end
 
     it "should add a order condition in the statment with WHERE and LIMIT" do
-      expect(@query.where("condition1 = 1").order("name desc").limit(1).to_s).to eq "SELECT Id, name, etc FROM table_name WHERE condition1 = 1 ORDER BY name desc LIMIT 1"
+      expect(query.where("condition1 = 1").order("name desc").limit(1).to_s).to eq "SELECT Id, name, etc FROM table_name WHERE (condition1 = 1) ORDER BY name desc LIMIT 1"
     end
   end
 
   describe '.join' do
-
-    before do
-      @join = ActiveForce::Query.new 'join_table_name'
-      @join.fields ['name', 'etc']
+    let(:join_query) do
+      join = ActiveForce::Query.new 'join_table_name'
+      join.fields ['name', 'etc']
+      join
     end
 
     it 'should add another select statment on the current select' do
-      expect(@query.join(@join).to_s).to eq 'SELECT Id, name, etc, (SELECT Id, name, etc FROM join_table_name) FROM table_name'
+      expect(query.join(join_query).to_s).to eq 'SELECT Id, name, etc, (SELECT Id, name, etc FROM join_table_name) FROM table_name'
     end
   end
 
   describe '.first' do
     it 'should return the query for the first record' do
-      expect(@query.first.to_s).to eq 'SELECT Id, name, etc FROM table_name LIMIT 1'
+      expect(query.first.to_s).to eq 'SELECT Id, name, etc FROM table_name LIMIT 1'
     end
   end
 
   describe '.last' do
     it 'should return the query for the last record' do
-      expect(@query.last.to_s).to eq 'SELECT Id, name, etc FROM table_name ORDER BY Id DESC LIMIT 1'
+      expect(query.last.to_s).to eq 'SELECT Id, name, etc FROM table_name ORDER BY Id DESC LIMIT 1'
     end
   end
 
   describe ".count" do
     it "should return the query for getting the row count" do
-      expect(@query.count.to_s).to eq 'SELECT count(Id) FROM table_name'
+      expect(query.count.to_s).to eq 'SELECT count(Id) FROM table_name'
     end
 
     it "should work with a condition" do
-      expect(@query.where("name = 'cool'").count.to_s).to eq "SELECT count(Id) FROM table_name WHERE name = 'cool'"
-    end
-  end
-
-  describe '.options' do
-    it 'should add a where if the option has a where condition' do
-      expect(@query.options(where: 'var = 1').to_s).to eq "SELECT Id, name, etc FROM table_name WHERE var = 1"
-    end
-
-    it 'should add a limit if the option has a limit condition' do
-      expect(@query.options(limit: 1).to_s).to eq "SELECT Id, name, etc FROM table_name LIMIT 1"
-    end
-
-    it 'should add a order if the option has a order condition' do
-      expect(@query.options(order: 'name desc').to_s).to eq "SELECT Id, name, etc FROM table_name ORDER BY name desc"
-    end
-
-    it 'should work with multiples options' do
-      expect(@query.options(where: 'var = 1', order: 'name desc', limit: 1).to_s).to eq "SELECT Id, name, etc FROM table_name WHERE var = 1 ORDER BY name desc LIMIT 1"
+      expect(query.where("name = 'cool'").count.to_s).to eq "SELECT count(Id) FROM table_name WHERE (name = 'cool')"
     end
   end
 end

data/spec/active_force/sobject/includes_spec.rb

@@ -0,0 +1,290 @@
+require 'spec_helper'
+
+module ActiveForce
+  describe SObject do
+    let(:client){ double "client" }
+
+    before do
+      allow(ActiveForce::SObject).to receive(:sfdc_client).and_return client
+    end
+
+    describe '.includes' do
+      context 'belongs_to' do
+        it 'queries the API for the associated record' do
+          soql = Territory.includes(:quota).where(id: '123').to_s
+          expect(soql).to eq "SELECT Id, Quota__c, Name, Quota__r.Bar_Id__c FROM Territory WHERE (Id = '123')"
+        end
+
+        it "queries the API once to retrieve the object and its related one" do
+          response = [build_restforce_sobject({
+            "Id"       => "123",
+            "Quota__c" => "321",
+            "Quota__r" => {
+              "Bar_Id__c" => "321"
+            }
+          })]
+          allow(client).to receive(:query).once.and_return response
+          territory = Territory.includes(:quota).find "123"
+          expect(territory.quota).to be_a Quota
+          expect(territory.quota.id).to eq "321"
+        end
+
+        it "queries the API once to retrieve the object and its related one" do
+          response = [build_restforce_sobject({
+            "Id"       => "123",
+            "Quota__c" => "321",
+            "Quota__r" => {
+              "Bar_Id__c" => "321"
+            }
+          })]
+          allow(client).to receive(:query).once.and_return response
+          territory = Territory.includes(:quota).find "123"
+          expect(territory.quota).to be_a Quota
+          expect(territory.quota.id).to eq "321"
+        end
+
+        context 'with namespaced SObjects' do
+          it 'queries the API for the associated record' do
+            soql = Salesforce::Territory.includes(:quota).where(id: '123').to_s
+            expect(soql).to eq "SELECT Id, QuotaId, WidgetId, Quota__r.Id FROM Territory WHERE (Id = '123')"
+          end
+
+          it "queries the API once to retrieve the object and its related one" do
+            response = [build_restforce_sobject({
+              "Id"       => "123",
+              "QuotaId"  => "321",
+              "WidgetId" => "321",
+              "Quota__r" => {
+                "Id" => "321"
+              }
+            })]
+            allow(client).to receive(:query).once.and_return response
+            territory = Salesforce::Territory.includes(:quota).find "123"
+            expect(territory.quota).to be_a Salesforce::Quota
+            expect(territory.quota.id).to eq "321"
+          end
+
+          context 'when the relationship table name is different from the actual table name' do
+            it 'formulates the correct SOQL' do
+              soql = Salesforce::Opportunity.includes(:owner).where(id: '123').to_s
+              expect(soql).to eq "SELECT Id, OwnerId, AccountId, Business_Partner__c, Owner.Id FROM Opportunity WHERE (Id = '123')"
+            end
+
+            it "queries the API once to retrieve the object and its related one" do
+              response = [build_restforce_sobject({
+                "Id"       => "123",
+                "OwnerId"  => "321",
+                "AccountId"  => "432",
+                "Owner" => {
+                  "Id" => "321"
+                }
+              })]
+              allow(client).to receive(:query).once.and_return response
+              opportunity = Salesforce::Opportunity.includes(:owner).find "123"
+              expect(opportunity.owner).to be_a Salesforce::User
+              expect(opportunity.owner.id).to eq "321"
+            end
+          end
+
+          context 'when the class name does not match the SFDC entity name' do
+            let(:expected_soql) do
+              "SELECT Id, QuotaId, WidgetId, Tegdiw__r.Id FROM Territory WHERE (Id = '123')"
+            end
+
+            it 'queries the API for the associated record' do
+              soql = Salesforce::Territory.includes(:widget).where(id: '123').to_s
+              expect(soql).to eq expected_soql
+            end
+
+            it "queries the API once to retrieve the object and its related one" do
+              response = [build_restforce_sobject({
+                "Id"        => "123",
+                "WidgetId"  => "321",
+                "Tegdiw__r" => {
+                  "Id" => "321"
+                }
+              })]
+              expected = expected_soql + ' LIMIT 1'
+              allow(client).to receive(:query).once.with(expected).and_return response
+              territory = Salesforce::Territory.includes(:widget).find "123"
+              expect(territory.widget).to be_a Salesforce::Widget
+              expect(territory.widget.id).to eq "321"
+            end
+          end
+
+          context 'child to several parents' do
+            it 'queries the API for associated records' do
+              soql = Salesforce::Territory.includes(:quota, :widget).where(id: '123').to_s
+              expect(soql).to eq "SELECT Id, QuotaId, WidgetId, Quota__r.Id, Tegdiw__r.Id FROM Territory WHERE (Id = '123')"
+            end
+
+            it "queries the API once to retrieve the object and its assocations" do
+              response = [build_restforce_sobject({
+                "Id"       => "123",
+                "QuotaId"  => "321",
+                "WidgetId" => "321",
+                "Quota__r" => {
+                  "Id" => "321"
+                },
+                "Tegdiw__r" => {
+                  "Id" => "321"
+                }
+              })]
+              allow(client).to receive(:query).once.and_return response
+              territory = Salesforce::Territory.includes(:quota, :widget).find "123"
+              expect(territory.quota).to be_a Salesforce::Quota
+              expect(territory.quota.id).to eq "321"
+              expect(territory.widget).to be_a Salesforce::Widget
+              expect(territory.widget.id).to eq "321"
+            end
+          end
+        end
+
+        context 'when there is no associated record' do
+          it "queries the API once to retrieve the object and its related one" do
+            response = [build_restforce_sobject({
+              "Id"       => "123",
+              "Quota__c" => "321",
+              "Quota__r" => nil
+            })]
+            allow(client).to receive(:query).once.and_return response
+            territory = Territory.includes(:quota).find "123"
+            expect(territory.quota).to be_nil
+            expect(territory.quota).to be_nil
+          end
+        end
+      end
+
+      context 'has_many' do
+        context 'with standard objects' do
+          it 'formulates the correct SOQL query' do
+            soql = Account.includes(:opportunities).where(id: '123').to_s
+            expect(soql).to eq "SELECT Id, OwnerId, (SELECT Id, AccountId FROM Opportunities) FROM Account WHERE (Id = '123')"
+          end
+
+          it 'builds the associated objects and caches them' do
+            response = [build_restforce_sobject({
+              'Id' => '123',
+              'Opportunities' => build_restforce_collection([
+                {'Id' => '213', 'AccountId' => '123'},
+                {'Id' => '214', 'AccountId' => '123'}
+              ])
+            })]
+            allow(client).to receive(:query).once.and_return response
+            account = Account.includes(:opportunities).find '123'
+            expect(account.opportunities).to be_an Array
+            expect(account.opportunities.all? { |o| o.is_a? Opportunity }).to eq true
+          end
+        end
+
+        context 'with custom objects' do
+          it 'formulates the correct SOQL query' do
+            soql = Quota.includes(:prez_clubs).where(id: '123').to_s
+            expect(soql).to eq "SELECT Id, Bar_Id__c, (SELECT Id, QuotaId FROM PrezClubs__r) FROM Quota__c WHERE (Bar_Id__c = '123')"
+          end
+
+          it 'builds the associated objects and caches them' do
+            response = [build_restforce_sobject({
+              'Id' => '123',
+              'PrezClubs__r' => build_restforce_collection([
+                {'Id' => '213', 'QuotaId' => '123'},
+                {'Id' => '214', 'QuotaId' => '123'}
+              ])
+            })]
+            allow(client).to receive(:query).once.and_return response
+            account = Quota.includes(:prez_clubs).find '123'
+            expect(account.prez_clubs).to be_an Array
+            expect(account.prez_clubs.all? { |o| o.is_a? PrezClub }).to eq true
+          end
+        end
+
+        context 'mixing standard and custom objects' do
+          it 'formulates the correct SOQL query' do
+            soql = Quota.includes(:territories, :prez_clubs).where(id: '123').to_s
+            expect(soql).to eq "SELECT Id, Bar_Id__c, (SELECT Id, Quota__c, Name FROM Territories), (SELECT Id, QuotaId FROM PrezClubs__r) FROM Quota__c WHERE (Bar_Id__c = '123')"
+          end
+
+          it 'builds the associated objects and caches them' do
+            response = [build_restforce_sobject({
+              'Id' => '123',
+              'PrezClubs__r' => build_restforce_collection([
+                {'Id' => '213', 'QuotaId' => '123'},
+                {'Id' => '214', 'QuotaId' => '123'}
+              ]),
+              'Territories' => build_restforce_collection([
+                {'Id' => '213', 'Quota__c' => '123'},
+                {'Id' => '214', 'Quota__c' => '123'}
+              ])
+            })]
+            allow(client).to receive(:query).once.and_return response
+            account = Quota.includes(:territories, :prez_clubs).find '123'
+            expect(account.prez_clubs).to be_an Array
+            expect(account.prez_clubs.all? { |o| o.is_a? PrezClub }).to eq true
+            expect(account.territories).to be_an Array
+            expect(account.territories.all? { |o| o.is_a? Territory }).to eq true
+          end
+        end
+
+        context 'with namespaced SObjects' do
+          it 'formulates the correct SOQL query' do
+            soql = Salesforce::Quota.includes(:prez_clubs).where(id: '123').to_s
+            expect(soql).to eq "SELECT Id, (SELECT Id, QuotaId FROM PrezClubs__r) FROM Quota__c WHERE (Id = '123')"
+          end
+
+          it 'builds the associated objects and caches them' do
+            response = [build_restforce_sobject({
+              'Id' => '123',
+              'PrezClubs__r' => build_restforce_collection([
+                {'Id' => '213', 'QuotaId' => '123'},
+                {'Id' => '214', 'QuotaId' => '123'}
+              ])
+            })]
+            allow(client).to receive(:query).once.and_return response
+            account = Salesforce::Quota.includes(:prez_clubs).find '123'
+            expect(account.prez_clubs).to be_an Array
+            expect(account.prez_clubs.all? { |o| o.is_a? Salesforce::PrezClub }).to eq true
+          end
+        end
+
+        context 'when there are no associated records returned by the query' do
+          it 'caches the response' do
+            response = [build_restforce_sobject({
+              'Id' => '123',
+              'Opportunities' => nil
+            })]
+            allow(client).to receive(:query).once.and_return response
+            account = Account.includes(:opportunities).find '123'
+            expect(account.opportunities).to eq []
+            expect(account.opportunities).to eq []
+          end
+        end
+      end
+
+      describe 'mixing belongs_to and has_many' do
+        it 'formulates the correct SOQL query' do
+          soql = Account.includes(:opportunities, :owner).where(id: '123').to_s
+          expect(soql).to eq "SELECT Id, OwnerId, (SELECT Id, AccountId FROM Opportunities), Owner__r.Id FROM Account WHERE (Id = '123')"
+        end
+
+        it 'builds the associated objects and caches them' do
+          response = [build_restforce_sobject({
+            'Id' => '123',
+            'Opportunities' => build_restforce_collection([
+              {'Id' => '213', 'AccountId' => '123'},
+              {'Id' => '214', 'AccountId' => '123'}
+            ]),
+            'Owner__r' => {
+              'Id' => '321'
+            }
+          })]
+          allow(client).to receive(:query).once.and_return response
+          account = Account.includes(:opportunities).find '123'
+          expect(account.opportunities).to be_an Array
+          expect(account.opportunities.all? { |o| o.is_a? Opportunity }).to eq true
+          expect(account.owner).to be_a Owner
+          expect(account.owner.id).to eq '321'
+        end
+      end
+    end
+  end
+end