active_force 0.7.1 → 0.15.0

data/spec/active_force/association_spec.rb

@@ -9,6 +9,14 @@ describe ActiveForce::SObject do
     Comment.new(id: "1", post_id: "1")
   end
 
+  let :has_one_parent do
+    HasOneParent.new(id: '1', comment: "BAR")
+  end
+
+  let :has_one_child do
+    HasOneChild.new(id: '1', has_one_parent_id: '1')
+  end
+
   let :client do
     double("sfdc_client", query: [Restforce::Mash.new("Id" => 1)])
   end
@@ -39,6 +47,19 @@ describe ActiveForce::SObject do
       end
     end
 
+    context 'when primary key is blank' do
+      let(:post) { Post.new }
+
+      it 'does not make any queries' do
+        post.comments.to_a
+        expect(client).not_to have_received :query
+      end
+
+      it 'returns empty' do
+        expect(post.comments.to_a).to be_empty
+      end
+    end
+
     context 'when the SObject is namespaced' do
       let(:account){ Foo::Account.new(id: '1') }
 
@@ -85,6 +106,197 @@ describe ActiveForce::SObject do
       soql = "SELECT Id, PostId, PosterId__c, FancyPostId, Body__c FROM Comment__c WHERE (PostId = '1')"
       expect(post.comments.to_s).to eq soql
     end
+
+    context 'when passing `model` option' do
+      before do
+        allow(Comment).to receive(:where).once.and_return([comment])
+      end
+
+      it 'allows passing as a constant' do
+        Post.has_many :comments, model: Comment
+        expect { post.comments }.to_not raise_error
+      end
+
+      it 'allows passing as a string' do
+        Post.has_many :comments, model: 'Comment'
+        expect { post.comments }.to_not raise_error
+      end
+    end
+  end
+
+  describe "has_one_query" do
+    it "should respond to relation method" do
+      expect(has_one_parent).to respond_to(:has_one_child)
+    end
+
+    it "should return a the correct child object" do
+      expect(has_one_parent.has_one_child).to be_a HasOneChild
+    end
+
+    it 'makes only one API call to fetch the associated object' do
+      has_one_parent.has_one_child.id
+      has_one_parent.has_one_child.id
+      expect(client).to have_received(:query).once
+    end
+
+    it 'queries for a single record with the correct foreign key' do
+      expected = <<~SOQL.squish
+        SELECT Id, has_one_parent_id__c, FancyParentId FROM HasOneChild__c WHERE (has_one_parent_id__c = '1') LIMIT 1
+      SOQL
+      has_one_parent.has_one_child
+      expect(client).to have_received(:query).with(expected)
+    end
+
+    context 'when primary key is blank' do
+      let(:parent) { HasOneParent.new }
+
+      it 'does not make any queries' do
+        parent.has_one_child
+        expect(client).not_to have_received :query
+      end
+
+      it 'returns nil' do
+        expect(parent.has_one_child).to be_nil
+      end
+    end
+
+    describe "assignments" do
+      let(:has_one) do
+        has_one_parent = HasOneParent.new(id: '1')
+        has_one_parent.has_one_child = HasOneChild.new(id: '1')
+        has_one_parent
+      end
+
+      before do
+        expect(client).to_not receive(:query)
+      end
+
+      it 'accepts assignment of an existing object as an association' do
+        expect(client).to_not receive(:query)
+        other_child = HasOneChild.new(id: '2')
+        has_one.has_one_child = other_child
+        expect(has_one.has_one_child.has_one_parent_id).to eq has_one.id
+        expect(has_one.has_one_child).to eq other_child
+      end
+
+      it 'uses first element if given Array' do
+        first_child = HasOneChild.new(id: '2')
+        has_one.has_one_child = [first_child, HasOneChild.new(id: '3')]
+        expect(has_one.has_one_child.has_one_parent_id).to eq has_one.id
+        expect(has_one.has_one_child).to eq first_child
+      end
+
+      it 'can desassociate an object by setting it as nil' do
+        old_child = has_one.has_one_child
+        has_one.has_one_child = nil
+        expect(old_child.has_one_parent_id).to eq nil
+        expect(has_one.has_one_child).to eq nil
+      end
+
+      context 'when primary key is blank' do
+        let(:child) { HasOneChild.new }
+        let(:parent) { HasOneParent.new }
+
+        it 'accepts assignment' do
+          parent.has_one_child = child
+          expect(parent.has_one_child).to eq(child)
+        end
+
+        it 'accepts reassignment' do
+          parent.has_one_child = child
+          other_child = HasOneChild.new(id: 'x')
+          parent.has_one_child = other_child
+          expect(parent.has_one_child).to eq(other_child)
+        end
+
+        it 'accepts nil assignment' do
+          parent.has_one_child = child
+          parent.has_one_child = nil
+          expect(parent.has_one_child).to be_nil
+        end
+
+        it 'assigns the first element if given an array' do
+          parent.has_one_child = [child, 'something else']
+          expect(parent.has_one_child).to eq(child)
+        end
+      end
+    end
+
+    context 'when the SObject is namespaced' do
+      let(:attachment){ Foo::Attachment.new(id: '1', lead_id: '2') }
+      let(:lead){ Foo::Lead.new(id: '2') }
+
+      it 'generates the correct query' do
+        expect(client).to receive(:query).with("SELECT Id, Lead_Id__c, LeadId FROM Attachment WHERE (Lead_Id__c = '2') LIMIT 1")
+        lead.attachment
+      end
+
+      it 'instantiates the correct object' do
+        expect(lead.attachment).to be_instance_of(Foo::Attachment)
+      end
+
+      context 'when given a foreign key' do
+        let(:lead) { Foo::Lead.new(id: '2') }
+
+        it 'generates the correct query' do
+          expect(client).to receive(:query).with("SELECT Id, Lead_Id__c, LeadId FROM Attachment WHERE (LeadId = '2') LIMIT 1")
+          lead.fancy_attachment
+        end
+      end
+    end
+  end
+
+  describe 'has_one(options)' do
+    it 'allows passing a foreign key' do
+      HasOneParent.has_one :has_one_child, foreign_key: :fancy_parent_id
+      allow(has_one_parent).to receive(:id).and_return "2"
+      expect(client).to receive(:query).with("SELECT Id, has_one_parent_id__c, FancyParentId FROM HasOneChild__c WHERE (FancyParentId = '2') LIMIT 1")
+      has_one_parent.has_one_child
+      HasOneParent.has_one :has_one_child, foreign_key: :has_one_parent_id # reset association to original value
+    end
+
+    context 'when passing `model` option' do
+      before do
+        allow(HasOneChild).to receive(:find_by).and_return(has_one_child)
+      end
+
+      it 'allows passing as a constant' do
+        HasOneParent.has_one :has_one_child, model: HasOneChild
+        expect { has_one_parent.has_one_child }.to_not raise_error
+      end
+
+      it 'allows passing as a string' do
+        HasOneParent.has_one :has_one_child, model: 'HasOneChild'
+        expect { has_one_parent.has_one_child }.to_not raise_error
+      end
+    end
+
+    context "when passing 'scoped_as' option" do
+      it 'makes a only single query if called more than once' do
+        post.last_comment
+        post.last_comment
+        expect(client).to have_received(:query).once
+      end
+
+      it 'applies the scope to the query' do
+        expected = <<~SOQL.squish
+          SELECT Id, PostId, PosterId__c, FancyPostId, Body__c FROM Comment__c
+          WHERE (NOT ((Body__c = NULL))) AND (PostId = '1') ORDER BY CreatedDate DESC LIMIT 1
+        SOQL
+        post.last_comment
+        expect(client).to have_received(:query).with(expected)
+      end
+
+      it 'applies the scope to the query if the lambda takes an argument' do
+        post.title = 'test_post_title'
+        expected = <<~SOQL.squish
+          SELECT Id, PostId, PosterId__c, FancyPostId, Body__c FROM Comment__c
+          WHERE (Body__c = 'test_post_title') AND (PostId = '1') LIMIT 1
+        SOQL
+        post.repeat_comment
+        expect(client).to have_received(:query).with(expected)
+      end
+    end
   end
 
   describe "belongs_to" do
@@ -92,20 +304,25 @@ describe ActiveForce::SObject do
       expect(comment.post).to be_instance_of(Post)
     end
 
-    it "should allow to pass a foreign key as options" do
-      Comment.belongs_to :post, foreign_key: :fancy_post_id
-      allow(comment).to receive(:fancy_post_id).and_return "2"
-      expect(client).to receive(:query).with("SELECT Id, Title__c FROM Post__c WHERE (Id = '2') LIMIT 1")
-      comment.post
-      Comment.belongs_to :post # reset association to original value
-    end
-
     it 'makes only one API call to fetch the associated object' do
       expect(client).to receive(:query).once
       comment.post
       comment.post
     end
 
+    context 'when foreign key is blank' do
+      let(:comment) { Comment.new(id: '1') }
+
+      it 'does not make any queries' do
+        comment.post
+        expect(client).not_to have_received :query
+      end
+
+      it 'returns nil' do
+        expect(comment.post).to be_nil
+      end
+    end
+
     describe "assignments" do
       let(:comment) do
         comment = Comment.new(id: '1')
@@ -116,7 +333,7 @@ describe ActiveForce::SObject do
       before do
         expect(client).to_not receive(:query)
       end
-      
+
       it 'accepts assignment of an existing object as an association' do
         expect(client).to_not receive(:query)
         other_post = Post.new(id: "2")
@@ -154,4 +371,30 @@ describe ActiveForce::SObject do
       end
     end
   end
+
+  describe 'belongs_to(options)' do
+    it 'allows passing a foreign key' do
+      Comment.belongs_to :post, foreign_key: :fancy_post_id
+      allow(comment).to receive(:fancy_post_id).and_return "2"
+      expect(client).to receive(:query).with("SELECT Id, Title__c FROM Post__c WHERE (Id = '2') LIMIT 1")
+      comment.post
+      Comment.belongs_to :post # reset association to original value
+    end
+
+    context 'when passing `model` option' do
+      before do
+        allow(Post).to receive(:find).once.and_return(post)
+      end
+
+      it 'allows passing as a constant' do
+        Comment.belongs_to :post, model: Post
+        expect { comment.post.id }.to_not raise_error
+      end
+
+      it 'allows passing as a string' do
+        Comment.belongs_to :post, model: 'Post'
+        expect { comment.post.id }.to_not raise_error
+      end
+    end
+  end
 end

data/spec/active_force/field_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe ActiveForce::Field do
+  let(:field) { ActiveForce::Field }
+
+  describe 'initialize' do
+    let(:some_field) { field.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 = field.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 field is' do
+    it 'a datetime should return a string like "YYYY-MM-DDTHH:MM:SSZ"' do
+      current_time = DateTime.now
+      names = field.new(:time, as: :datetime)
+      expect(names.value_for_hash current_time).to eq current_time.to_fs(:iso8601)
+    end
+
+    it 'a datetime field whose value is nil' do
+      current_time = nil
+      names = field.new(:time, as: :datetime)
+      expect(names.value_for_hash current_time).to be_nil
+    end
+  end
+end

data/spec/active_force/query_spec.rb

@@ -48,6 +48,22 @@ describe ActiveForce::Query do
     end
   end
 
+  describe ".not" do
+    let(:subquery) { ActiveForce::Query.new 'table_name' }
+
+    it 'should add a not condition' do
+      expect(query.not(['condition1 = 1']).to_s).to eq "SELECT Id, name, etc FROM table_name WHERE (NOT ((condition1 = 1)))"
+    end
+  end
+
+  describe ".or" do
+    let(:subquery) { ActiveForce::Query.new 'table_name' }
+
+    it 'should create an or condition' do
+      expect(query.where('condition1 = 1').where('condition2 = 2').or(subquery.where('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"
@@ -123,4 +139,14 @@ describe ActiveForce::Query do
       expect(query.where("name = 'cool'").count.to_s).to eq "SELECT count(Id) FROM table_name WHERE (name = 'cool')"
     end
   end
+
+  describe ".sum" do
+    it "should return the query for summing the desired column" do
+      expect(query.sum(:field1).to_s).to eq 'SELECT sum(field1) FROM table_name'
+    end
+
+    it "should work with a condition" do
+      expect(query.where("name = 'cool'").sum(:field1).to_s).to eq "SELECT sum(field1) FROM table_name WHERE (name = 'cool')"
+    end
+  end
 end

data/spec/active_force/sobject/includes_spec.rb

@@ -46,7 +46,7 @@ module ActiveForce
         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')"
+            expect(soql).to eq "SELECT Id, QuotaId, WidgetId, QuotaId.Id FROM Territory WHERE (Id = '123')"
           end
 
           it "queries the API once to retrieve the object and its related one" do
@@ -54,7 +54,7 @@ module ActiveForce
               "Id"       => "123",
               "QuotaId"  => "321",
               "WidgetId" => "321",
-              "Quota__r" => {
+              "QuotaId" => {
                 "Id" => "321"
               }
             })]
@@ -88,7 +88,7 @@ module ActiveForce
 
           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')"
+              "SELECT Id, QuotaId, WidgetId, WidgetId.Id FROM Territory WHERE (Id = '123')"
             end
 
             it 'queries the API for the associated record' do
@@ -100,7 +100,7 @@ module ActiveForce
               response = [build_restforce_sobject({
                 "Id"        => "123",
                 "WidgetId"  => "321",
-                "Tegdiw__r" => {
+                "WidgetId" => {
                   "Id" => "321"
                 }
               })]
@@ -115,7 +115,7 @@ module ActiveForce
           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')"
+              expect(soql).to eq "SELECT Id, QuotaId, WidgetId, QuotaId.Id, WidgetId.Id FROM Territory WHERE (Id = '123')"
             end
 
             it "queries the API once to retrieve the object and its assocations" do
@@ -123,10 +123,10 @@ module ActiveForce
                 "Id"       => "123",
                 "QuotaId"  => "321",
                 "WidgetId" => "321",
-                "Quota__r" => {
+                "QuotaId" => {
                   "Id" => "321"
                 },
-                "Tegdiw__r" => {
+                "WidgetId" => {
                   "Id" => "321"
                 }
               })]
@@ -263,7 +263,7 @@ module ActiveForce
       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')"
+          expect(soql).to eq "SELECT Id, OwnerId, (SELECT Id, AccountId FROM Opportunities), OwnerId.Id FROM Account WHERE (Id = '123')"
         end
 
         it 'builds the associated objects and caches them' do
@@ -273,12 +273,12 @@ module ActiveForce
               {'Id' => '213', 'AccountId' => '123'},
               {'Id' => '214', 'AccountId' => '123'}
             ]),
-            'Owner__r' => {
+            'OwnerId' => {
               'Id' => '321'
             }
           })]
           allow(client).to receive(:query).once.and_return response
-          account = Account.includes(:opportunities).find '123'
+          account = Account.includes(:opportunities, :owner).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