active_force 0.15.1 → 0.17.0

data/spec/active_force/active_query_spec.rb

@@ -9,7 +9,7 @@ describe ActiveForce::ActiveQuery do
     })
   end
   let(:mappings){ { id: "Id", field: "Field__c", other_field: "Other_Field" } }
-  let(:client){ double("client") }
+  let(:client) { double('client', query: nil) }
   let(:active_query){ described_class.new(sobject) }
   let(:api_result) do
     [
@@ -42,48 +42,45 @@ describe ActiveForce::ActiveQuery do
 
   describe "select only some field using mappings" do
     it "should return a query only with selected field" do
-      active_query.select(:field)
-      expect(active_query.to_s).to eq("SELECT Field__c FROM table_name")
+      new_query = active_query.select(:field)
+      expect(new_query.to_s).to eq("SELECT Field__c FROM table_name")
     end
   end
 
   describe "condition mapping" do
     it "maps conditions for a .where" do
-      active_query.where(field: 123)
-      expect(active_query.to_s).to eq("SELECT Id FROM table_name WHERE (Field__c = 123)")
+      new_query = active_query.where(field: 123)
+      expect(new_query.to_s).to eq("SELECT Id FROM table_name WHERE (Field__c = 123)")
     end
 
     it 'transforms an array to a WHERE/IN clause' do
-      active_query.where(field: ['foo', 'bar'])
-      expect(active_query.to_s).to eq("SELECT Id FROM table_name WHERE (Field__c IN ('foo','bar'))")
+      new_query = active_query.where(field: ['foo', 'bar'])
+      expect(new_query.to_s).to eq("SELECT Id FROM table_name WHERE (Field__c IN ('foo','bar'))")
     end
 
     it "encloses the value in quotes if it's a string" do
-      active_query.where field: "hello"
-      expect(active_query.to_s).to end_with("(Field__c = 'hello')")
+      new_query = active_query.where field: "hello"
+      expect(new_query.to_s).to end_with("(Field__c = 'hello')")
     end
 
     it "formats as YYYY-MM-DDThh:mm:ss-hh:mm and does not enclose in quotes if it's a DateTime" do
       value = DateTime.now
-      active_query.where(field: value)
-      expect(active_query.to_s).to end_with("(Field__c = #{value.iso8601})")
+      expect(active_query.where(field: value).to_s).to end_with("(Field__c = #{value.iso8601})")
     end
 
     it "formats as YYYY-MM-DDThh:mm:ss-hh:mm and does not enclose in quotes if it's a Time" do
       value = Time.now
-      active_query.where(field: value)
-      expect(active_query.to_s).to end_with("(Field__c = #{value.iso8601})")
+      expect(active_query.where(field: value).to_s).to end_with("(Field__c = #{value.iso8601})")
     end
 
     it "formats as YYYY-MM-DD and does not enclose in quotes if it's a Date" do
       value = Date.today
-      active_query.where(field: value)
-      expect(active_query.to_s).to end_with("(Field__c = #{value.iso8601})")
+      expect(active_query.where(field: value).to_s).to end_with("(Field__c = #{value.iso8601})")
     end
 
     it "puts NULL when a field is set as nil" do
-      active_query.where field: nil
-      expect(active_query.to_s).to end_with("(Field__c = NULL)")
+      new_query = active_query.where field: nil
+      expect(new_query.to_s).to end_with("(Field__c = NULL)")
     end
 
     describe 'bind parameters' do
@@ -95,36 +92,33 @@ describe ActiveForce::ActiveQuery do
       end
 
       it 'accepts bind parameters' do
-        active_query.where('Field__c = ?', 123)
-        expect(active_query.to_s).to eq("SELECT Id FROM table_name WHERE (Field__c = 123)")
+        new_query = active_query.where('Field__c = ?', 123)
+        expect(new_query.to_s).to eq("SELECT Id FROM table_name WHERE (Field__c = 123)")
       end
 
       it 'accepts nil bind parameters' do
-        active_query.where('Field__c = ?', nil)
-        expect(active_query.to_s).to eq("SELECT Id FROM table_name WHERE (Field__c = NULL)")
+        new_query = active_query.where('Field__c = ?', nil)
+        expect(new_query.to_s).to eq("SELECT Id FROM table_name WHERE (Field__c = NULL)")
       end
 
       it 'accepts multiple bind parameters' do
-        active_query.where('Field__c = ? AND Other_Field__c = ? AND Name = ?', 123, 321, 'Bob')
-        expect(active_query.to_s).to eq("SELECT Id FROM table_name WHERE (Field__c = 123 AND Other_Field__c = 321 AND Name = 'Bob')")
+        new_query = active_query.where('Field__c = ? AND Other_Field__c = ? AND Name = ?', 123, 321, 'Bob')
+        expect(new_query.to_s).to eq("SELECT Id FROM table_name WHERE (Field__c = 123 AND Other_Field__c = 321 AND Name = 'Bob')")
       end
 
       it 'formats as YYYY-MM-DDThh:mm:ss-hh:mm and does not enclose in quotes if value is a DateTime' do
         value = DateTime.now
-        active_query.where('Field__c > ?', value)
-        expect(active_query.to_s).to end_with("(Field__c > #{value.iso8601})")
+        expect(active_query.where('Field__c > ?', value).to_s).to end_with("(Field__c > #{value.iso8601})")
       end
 
       it 'formats as YYYY-MM-DDThh:mm:ss-hh:mm and does not enclose in quotes if value is a Time' do
         value = Time.now
-        active_query.where('Field__c > ?', value)
-        expect(active_query.to_s).to end_with("(Field__c > #{value.iso8601})")
+        expect(active_query.where('Field__c > ?', value).to_s).to end_with("(Field__c > #{value.iso8601})")
       end
 
       it 'formats as YYYY-MM-DD and does not enclose in quotes if value is a Date' do
         value = Date.today
-        active_query.where('Field__c > ?', value)
-        expect(active_query.to_s).to end_with("(Field__c > #{value.iso8601})")
+        expect(active_query.where('Field__c > ?', value).to_s).to end_with("(Field__c > #{value.iso8601})")
       end
 
       it 'complains when there given an incorrect number of bind parameters' do
@@ -135,41 +129,41 @@ describe ActiveForce::ActiveQuery do
 
       context 'named bind parameters' do
         it 'accepts bind parameters' do
-          active_query.where('Field__c = :field', field: 123)
-          expect(active_query.to_s).to eq("SELECT Id FROM table_name WHERE (Field__c = 123)")
+          new_query = active_query.where('Field__c = :field', field: 123)
+          expect(new_query.to_s).to eq("SELECT Id FROM table_name WHERE (Field__c = 123)")
         end
 
         it 'accepts nil bind parameters' do
-          active_query.where('Field__c = :field', field: nil)
-          expect(active_query.to_s).to eq("SELECT Id FROM table_name WHERE (Field__c = NULL)")
+          new_query = active_query.where('Field__c = :field', field: nil)
+          expect(new_query.to_s).to eq("SELECT Id FROM table_name WHERE (Field__c = NULL)")
         end
 
         it 'formats as YYYY-MM-DDThh:mm:ss-hh:mm and does not enclose in quotes if value is a DateTime' do
           value = DateTime.now
-          active_query.where('Field__c < :field', field: value)
-          expect(active_query.to_s).to end_with("(Field__c < #{value.iso8601})")
+          new_query = active_query.where('Field__c < :field', field: value)
+          expect(new_query.to_s).to end_with("(Field__c < #{value.iso8601})")
         end
 
         it 'formats as YYYY-MM-DDThh:mm:ss-hh:mm and does not enclose in quotes if value is a Time' do
           value = Time.now
-          active_query.where('Field__c < :field', field: value)
-          expect(active_query.to_s).to end_with("(Field__c < #{value.iso8601})")
+          new_query = active_query.where('Field__c < :field', field: value)
+          expect(new_query.to_s).to end_with("(Field__c < #{value.iso8601})")
         end
 
         it 'formats as YYYY-MM-DD and does not enclose in quotes if value is a Date' do
           value = Date.today
-          active_query.where('Field__c < :field', field: value)
-          expect(active_query.to_s).to end_with("(Field__c < #{value.iso8601})")
+          new_query = active_query.where('Field__c < :field', field: value)
+          expect(new_query.to_s).to end_with("(Field__c < #{value.iso8601})")
         end
 
         it 'accepts multiple bind parameters' do
-          active_query.where('Field__c = :field AND Other_Field__c = :other_field AND Name = :name', field: 123, other_field: 321, name: 'Bob')
-          expect(active_query.to_s).to eq("SELECT Id FROM table_name WHERE (Field__c = 123 AND Other_Field__c = 321 AND Name = 'Bob')")
+          new_query = active_query.where('Field__c = :field AND Other_Field__c = :other_field AND Name = :name', field: 123, other_field: 321, name: 'Bob')
+          expect(new_query.to_s).to eq("SELECT Id FROM table_name WHERE (Field__c = 123 AND Other_Field__c = 321 AND Name = 'Bob')")
         end
 
         it 'accepts multiple bind parameters orderless' do
-          active_query.where('Field__c = :field AND Other_Field__c = :other_field AND Name = :name', name: 'Bob', other_field: 321, field: 123)
-          expect(active_query.to_s).to eq("SELECT Id FROM table_name WHERE (Field__c = 123 AND Other_Field__c = 321 AND Name = 'Bob')")
+          new_query = active_query.where('Field__c = :field AND Other_Field__c = :other_field AND Name = :name', name: 'Bob', other_field: 321, field: 123)
+          expect(new_query.to_s).to eq("SELECT Id FROM table_name WHERE (Field__c = 123 AND Other_Field__c = 321 AND Name = 'Bob')")
         end
 
         it 'complains when there given an incorrect number of bind parameters' do
@@ -198,29 +192,77 @@ describe ActiveForce::ActiveQuery do
         {"Id" => "0000000000EEEEEFFF"}
       ]
     end
+
     it 'allows method chaining' do
       result = active_query.where("Text_Label = 'foo'").where("Checkbox_Label = true")
       expect(result).to be_a described_class
     end
 
+    it 'does not execute a query' do
+      active_query.where('x')
+      expect(client).not_to have_received(:query)
+    end
+
+    context 'when calling `where` on an ActiveQuery object that already has records' do
+      context 'after the query result has been decorated' do
+        it 'returns a new ActiveQuery object' do
+          first_active_query = active_query.where("Text_Label = 'foo'")
+          first_active_query.to_a # decorates the results
+          second_active_query = first_active_query.where("Checkbox_Label = true")
+          second_active_query.to_a
+          expect(second_active_query).to be_a described_class
+          expect(second_active_query).not_to eq first_active_query
+          expect(second_active_query.to_s).not_to eq first_active_query.to_s
+          expect(second_active_query.to_a.size).to eq(1)
+        end
+      end
+    end
+
     context 'when calling `where` on an ActiveQuery object that already has records' do
-      it 'returns a new ActiveQuery object' do
-        first_active_query = active_query.where("Text_Label = 'foo'")
-        first_active_query.inspect # so the query is executed
-        second_active_query = first_active_query.where("Checkbox_Label = true")
-        second_active_query.inspect
-        expect(second_active_query).to be_a described_class
-        expect(second_active_query).not_to eq first_active_query
+      context 'without the query result being decorated' do
+
+        it 'returns a new ActiveQuery object' do
+          first_active_query = active_query.where("Text_Label = 'foo'")
+          second_active_query = first_active_query.where("Checkbox_Label = true")
+          expect(second_active_query).to be_a described_class
+          expect(second_active_query).not_to eq first_active_query
+          expect(second_active_query.to_s).not_to eq first_active_query.to_s
+          expect(second_active_query.to_a.size).to eq(1)
+        end
       end
     end
+  end
 
+  describe '#not' do
+    it 'adds a not condition' do
+      expect(active_query.not(field: 'x').to_s).to end_with("WHERE (NOT ((Field__c = 'x')))")
+    end
+
+    it 'allows chaining' do
+      expect(active_query.where(field: 'x').not(field: 'y').where(field: 'z')).to be_a(described_class)
+    end
+
+    it 'does not mutate the original query' do
+      original = active_query.to_s
+      active_query.not(field: 'x')
+      expect(active_query.to_s).to eq(original)
+    end
+
+    it 'returns the original query if not given a condition' do
+      expect(active_query.not).to be(active_query)
+    end
+
+    it 'does not execute a query' do
+      active_query.not(field: 'x')
+      expect(client).not_to have_received(:query)
+    end
   end
 
   describe "#find_by" do
     it "should query the client, with the SFDC field names and correctly enclosed values" do
-      expect(client).to receive :query
-      active_query.find_by field: 123
-      expect(active_query.to_s).to eq "SELECT Id FROM table_name WHERE (Field__c = 123) LIMIT 1"
+      expect(client).to receive(:query).with("SELECT Id FROM table_name WHERE (Field__c = 123) LIMIT 1")
+      new_query = active_query.find_by field: 123
+      expect(new_query).to be_nil
     end
   end
 
@@ -290,18 +332,18 @@ describe ActiveForce::ActiveQuery do
     let(:expected_query){ "SELECT Id FROM table_name WHERE (Backslash_Field__c = '\\\\' AND NumberField = 123 AND QuoteField = '\\' OR Id!=NULL OR Id=\\'')" }
 
     it 'escapes quotes and backslashes in bind parameters' do
-      active_query.where('Backslash_Field__c = :backslash_field AND NumberField = :number_field AND QuoteField = :quote_field', number_field: number_input, backslash_field: backslash_input, quote_field: quote_input)
-      expect(active_query.to_s).to eq(expected_query)
+      new_query = active_query.where('Backslash_Field__c = :backslash_field AND NumberField = :number_field AND QuoteField = :quote_field', number_field: number_input, backslash_field: backslash_input, quote_field: quote_input)
+      expect(new_query.to_s).to eq(expected_query)
     end
 
     it 'escapes quotes and backslashes in named bind parameters' do
-      active_query.where('Backslash_Field__c = ? AND NumberField = ? AND QuoteField = ?', backslash_input, number_input, quote_input)
-      expect(active_query.to_s).to eq(expected_query)
+      new_query = active_query.where('Backslash_Field__c = ? AND NumberField = ? AND QuoteField = ?', backslash_input, number_input, quote_input)
+      expect(new_query.to_s).to eq(expected_query)
     end
 
     it 'escapes quotes and backslashes in hash conditions' do
-      active_query.where(backslash_field: backslash_input, number_field: number_input, quote_field: quote_input)
-      expect(active_query.to_s).to eq("SELECT Id FROM table_name WHERE (Backslash_Field__c = '\\\\') AND (NumberField = 123) AND (QuoteField = '\\' OR Id!=NULL OR Id=\\'')")
+      new_query = active_query.where(backslash_field: backslash_input, number_field: number_input, quote_field: quote_input)
+      expect(new_query.to_s).to eq("SELECT Id FROM table_name WHERE (Backslash_Field__c = '\\\\') AND (NumberField = 123) AND (QuoteField = '\\' OR Id!=NULL OR Id=\\'')")
     end
   end
 

data/spec/active_force/association_spec.rb

@@ -40,6 +40,16 @@ describe ActiveForce::SObject do
       post.comments.to_a
     end
 
+    it 'is not mutated by #where' do
+      post.comments.where(body: 'test').to_a
+      expect(post.comments.to_s).to end_with("FROM Comment__c WHERE (PostId = '1')")
+    end
+
+    it 'is not mutated by #none' do
+      post.comments.none.to_a
+      expect(post.comments.to_s).to end_with("FROM Comment__c WHERE (PostId = '1')")
+    end
+
     describe 'to_s' do
       it "should return a SOQL statment" do
         soql = "SELECT Id, PostId, PosterId__c, FancyPostId, Body__c FROM Comment__c WHERE (PostId = '1')"
@@ -376,7 +386,7 @@ describe ActiveForce::SObject 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")
+      expect(client).to receive(:query).with("SELECT Id, Title__c, BlogId FROM Post__c WHERE (Id = '2') LIMIT 1")
       comment.post
       Comment.belongs_to :post # reset association to original value
     end

data/spec/active_force/query_spec.rb

@@ -32,7 +32,7 @@ describe ActiveForce::Query do
       expect(query.all.to_s).to eq "SELECT Id, name, etc FROM table_name"
     end
 
-    it "should ignore dupicated attributes in select statment" do
+    it "should ignore duplicated attributes in select statment" do
       query.fields ['Id', 'name', 'etc']
       expect(query.all.to_s).to eq "SELECT Id, name, etc FROM table_name"
     end
@@ -46,6 +46,19 @@ describe ActiveForce::Query do
     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
+
+    it "should not duplicate conditions" do
+      first_query = query.where("name = 'cool'").where("foo = 'baz'")
+      second_query = first_query.where("name = 'cool'")
+      expect(first_query.to_s).to eq(second_query.to_s)
+      expect(first_query.object_id).to eq(second_query.object_id)
+    end
+
+    it "should not update the original query" do
+      new_query = query.where("name = 'cool'")
+      expect(query.to_s).to eq "SELECT Id, name, etc FROM table_name"
+      expect(new_query.to_s).to eq "SELECT Id, name, etc FROM table_name WHERE (name = 'cool')"
+    end
   end
 
   describe ".not" do
@@ -68,12 +81,18 @@ describe ActiveForce::Query 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"
     end
+
+    it "should not update the original query" do
+      new_query = query.limit("25")
+      expect(query.to_s).to eq "SELECT Id, name, etc FROM table_name"
+      expect(new_query.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
+      new_query = query.limit(4)
+      expect(new_query.limit_value).to eq 4
     end
   end
 
@@ -81,12 +100,18 @@ describe ActiveForce::Query 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"
     end
+
+    it "should not update the original query" do
+      new_query = query.offset(4)
+      expect(query.to_s).to eq "SELECT Id, name, etc FROM table_name"
+      expect(new_query.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
+      new_query = query.offset(4)
+      expect(new_query.offset_value).to eq 4
     end
   end
 
@@ -104,6 +129,12 @@ describe ActiveForce::Query do
     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"
     end
+
+    it "should not update the original query" do
+      ordered_query = query.order("name desc")
+      expect(query.to_s).to eq "SELECT Id, name, etc FROM table_name"
+      expect(ordered_query.to_s).to eq "SELECT Id, name, etc FROM table_name ORDER BY name desc"
+    end
   end
 
   describe '.join' do
@@ -116,18 +147,36 @@ describe ActiveForce::Query do
     it 'should add another select statment on the current select' do
       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
+
+    it "should not update the original query" do
+      new_query = query.join(join_query)
+      expect(query.to_s).to eq "SELECT Id, name, etc FROM table_name"
+      expect(new_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'
     end
+
+    it "should not update the original query" do
+      new_query = query.first
+      expect(query.to_s).to eq "SELECT Id, name, etc FROM table_name"
+      expect(new_query.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'
     end
+
+    it "should not update the original query" do
+      new_query = query.last
+      expect(query.to_s).to eq "SELECT Id, name, etc FROM table_name"
+      expect(new_query.to_s).to eq 'SELECT Id, name, etc FROM table_name ORDER BY Id DESC LIMIT 1'
+    end
   end
 
   describe ".count" do
@@ -138,6 +187,12 @@ describe ActiveForce::Query do
     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
+
+    it "should not update the original query" do
+      query_with_count = query.where("name = 'cool'").count
+      expect(query.to_s).to eq "SELECT Id, name, etc FROM table_name"
+      expect(query_with_count.to_s).to eq "SELECT count(Id) FROM table_name WHERE (name = 'cool')"
+    end
   end
 
   describe ".sum" do