active_force 0.16.0 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7691f9f6f82d893a6aafdf29cfc6228ab2fe31988fafcf5be95070347a0286de
-  data.tar.gz: 4d0da25e5e12f9014407dba1871953a0b05f58227188d53130eba27dd537aa4d
+  metadata.gz: 6de1df55a3215360cd78f76fa3f55d05ca9e8f9f9603d5ab4257667a5fd961a5
+  data.tar.gz: e85f2ae5bd075070adc261ec3a6d566eea2f9cf19c4d4423fa1b859cafdabcc4
 SHA512:
-  metadata.gz: 2e8cf96c34eb81e3e4236455538bc462de07d02f7149ab064125d4c86f52a96c7e61e98ff91b9fe48e3b5b6d79d88ded4bb47966800f021e153a970adac802b4
-  data.tar.gz: 6b7edaa7cf4161921b1d42c3a26fe896781bd3198ce981b2693852f3fe3ff6f1690e27e61ec781761fbe06d10634fc720013f1b2f3a266d3de6a189dd37af2a5
+  metadata.gz: 5268395d3fcc92a705b909026b6de6deb36b4c6a9b622d0ee63307ed08d16142e96abca2bafb902c55fca02955d75c34aa3348eb84fc14c47784d3548b492f89
+  data.tar.gz: 3ea676afd55bb62601e211250c487a86e7902f1dee1f8b6fdc41410b903ce2052e5a4f893cc869798ba3bf5c1270aad2c84ea21c24dd137909e494e7c0564ff9

data/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## Not released
 
+## 0.18.0
+
+- Fix eager loading of scoped associations. (https://github.com/Beyond-Finance/active_force/pull/67)
+- Adding `.blank?`, `.present?`, and `.any?` delegators to `ActiveQuery`. (https://github.com/Beyond-Finance/active_force/pull/68)
+- Adding `update` and `update!` class methods on `SObject`. (https://github.com/Beyond-Finance/active_force/pull/66)
+- Allow an argument to `last` allowing the query to select the `last(n)` records. Default is 1. (https://github.com/Beyond-Finance/active_force/pull/66)
+
+## 0.17.0
+
+- Fix bug with has_many queries due to query method chaining mutating in-place (https://github.com/Beyond-Finance/active_force/pull/10)
+
 ## 0.16.0
 
 - Fix `default` in models when default value is overridden by the same value, it is still sent to salesforce (https://github.com/Beyond-Finance/active_force/pull/61)

data/lib/active_force/active_query.rb

@@ -21,9 +21,9 @@ module ActiveForce
     attr_reader :sobject, :association_mapping, :belongs_to_association_mapping
 
     def_delegators :sobject, :sfdc_client, :build, :table_name, :mappings
-    def_delegators :to_a, :each, :map, :inspect, :pluck, :each_with_object
+    def_delegators :to_a, :blank?, :present?, :any?, :each, :map, :inspect, :pluck, :each_with_object
 
-    def initialize (sobject, custom_table_name = nil)
+    def initialize(sobject, custom_table_name = nil)
       @sobject = sobject
       @association_mapping = {}
       @belongs_to_association_mapping = {}
@@ -42,36 +42,34 @@ module ActiveForce
     alias_method :all, :to_a
 
     def count
-      super
-      sfdc_client.query(to_s).first.expr0
+      sfdc_client.query(super.to_s).first.expr0
     end
 
     def sum field
-      super(mappings[field])
-      sfdc_client.query(to_s).first.expr0
+      raise ArgumentError, 'field is required' if field.blank?
+      raise ArgumentError, "field '#{field}' does not exist on #{sobject}" unless mappings.key?(field.to_sym)
+
+      sfdc_client.query(super(mappings.fetch(field.to_sym)).to_s).first.expr0
     end
 
     def limit limit
-      super
-      limit == 1 ? to_a.first : self
+      limit == 1 ? super.to_a.first : super
     end
 
     def not args=nil, *rest
       return self if args.nil?
+
       super build_condition args, rest
-      self
     end
 
     def where args=nil, *rest
       return self if args.nil?
-      return clone_self_and_clear_cache.where(args, *rest) if @decorated_records.present?
       super build_condition args, rest
-      self
     end
 
-    def select *fields
-      fields.map! { |field| mappings[field] }
-      super *fields
+    def select *selected_fields
+      selected_fields.map! { |field| mappings[field] }
+      super *selected_fields
     end
 
     def find!(id)
@@ -100,8 +98,10 @@ module ActiveForce
     end
 
     def none
-      @records = []
-      where(id: '1'*18).where(id: '0'*18)
+      clone_and_set_instance_variables(
+        records: [],
+        conditions: [build_condition(id: '1' * 18), build_condition(id: '0' * 18)]
+      )
     end
 
     def loaded?
@@ -205,13 +205,6 @@ module ActiveForce
       sfdc_client.query(self.to_s)
     end
 
-    def clone_self_and_clear_cache
-      new_query = self.clone
-      new_query.instance_variable_set(:@decorated_records, nil)
-      new_query.instance_variable_set(:@records, nil)
-      new_query
-    end
-
     def build_order_by(args)
       args.map do |arg|
         case arg
@@ -228,6 +221,5 @@ module ActiveForce
     def order_type(type)
       type == :desc ? 'DESC' : 'ASC'
     end
-
   end
 end

data/lib/active_force/association/association.rb

@@ -26,6 +26,14 @@ module ActiveForce
         options[:relationship_name] || relation_model.to_s.constantize.table_name
       end
 
+      def scoped_as
+        options[:scoped_as] || nil
+      end
+
+      def scoped?
+        options[:scoped_as].present?
+      end
+
       ###
       # Does this association's relation_model represent
       # +sfdc_table_name+? Examples of +sfdc_table_name+

data/lib/active_force/association/eager_load_projection_builder.rb

@@ -1,5 +1,6 @@
 module ActiveForce
   module Association
+    class InvalidEagerLoadAssociation < StandardError; end
     class EagerLoadProjectionBuilder
       class << self
         def build(association, parent_association_field = nil)
@@ -34,6 +35,13 @@ module ActiveForce
       def projections
         raise "Must define #{self.class.name}#projections"
       end
+
+      def apply_association_scope(query)
+        return query unless association.scoped?
+        raise InvalidEagerLoadAssociation, "Cannot use scopes that expect arguments: #{association.relation_name}" if association.scoped_as.arity.positive?
+
+        query.instance_exec(&association.scoped_as)
+      end
     end
 
     class HasManyAssociationProjectionBuilder < AbstractProjectionBuilder
@@ -43,17 +51,17 @@ module ActiveForce
       # to be pluralized
       def projections
         relationship_name = association.sfdc_association_field
-        query = Query.new relationship_name
+        query = ActiveQuery.new(association.relation_model, relationship_name)
         query.fields association.relation_model.fields
-        ["(#{query.to_s})"]
+        ["(#{apply_association_scope(query).to_s})"]
       end
     end
 
     class HasOneAssociationProjectionBuilder < AbstractProjectionBuilder
       def projections
-        query = Query.new association.sfdc_association_field
+        query = ActiveQuery.new(association.relation_model, association.sfdc_association_field)
         query.fields association.relation_model.fields
-        ["(#{query.to_s})"]
+        ["(#{apply_association_scope(query).to_s})"]
       end
     end
 

data/lib/active_force/query.rb

@@ -31,33 +31,34 @@ module ActiveForce
     end
 
     def select *columns
-      @query_fields = columns
-      self
+      clone_and_set_instance_variables(query_fields: columns)
+    end
+
+    def where condition = nil
+      new_conditions = @conditions | [condition]
+      if new_conditions != @conditions
+        clone_and_set_instance_variables({conditions: new_conditions})
+      else
+        self
+      end
     end
 
     def not condition
-      @conditions << "NOT ((#{ condition.join(') AND (') }))"
-      self
+      condition ? where("NOT ((#{condition.join(') AND (')}))") : self
     end
 
     def or query
-      @conditions = ["(#{ and_conditions }) OR (#{ query.and_conditions })"]
-      self
-    end
+      return self unless query
 
-    def where condition = nil
-      @conditions << condition if condition
-      self
+      clone_and_set_instance_variables(conditions: ["(#{and_conditions}) OR (#{query.and_conditions})"])
     end
 
     def order order
-      @order = order if order
-      self
+      order ? clone_and_set_instance_variables(order: order) : self
     end
 
     def limit size
-      @size = size if size
-      self
+      size ? clone_and_set_instance_variables(size: size) : self
     end
 
     def limit_value
@@ -65,8 +66,7 @@ module ActiveForce
     end
 
     def offset offset
-      @offset = offset
-      self
+      clone_and_set_instance_variables(offset: offset)
     end
 
     def offset_value
@@ -74,31 +74,29 @@ module ActiveForce
     end
 
     def find id
-      where "#{ @table_id } = '#{ id }'"
-      limit 1
+      where("#{ @table_id } = '#{ id }'").limit 1
     end
 
     def first
       limit 1
     end
 
-    def last
-      order("Id DESC").limit(1)
+    def last(limit = 1)
+      order("Id DESC").limit(limit)
     end
 
     def join object_query
-      fields ["(#{ object_query.to_s })"]
-      self
+      chained_query = self.clone
+      chained_query.fields ["(#{ object_query.to_s })"]
+      chained_query
     end
 
     def count
-      @query_fields = ["count(Id)"]
-      self
+      clone_and_set_instance_variables(query_fields: ["count(Id)"])
     end
 
     def sum field
-      @query_fields = ["sum(#{field})"]
-      self
+      clone_and_set_instance_variables(query_fields: ["sum(#{field})"])
     end
 
     protected
@@ -125,5 +123,13 @@ module ActiveForce
       def build_offset
         "OFFSET #{ @offset }" if @offset
       end
+
+      def clone_and_set_instance_variables instance_variable_hash={}
+        clone = self.clone
+        clone.instance_variable_set(:@decorated_records, nil)
+        clone.instance_variable_set(:@records, nil)
+        instance_variable_hash.each { |k,v| clone.instance_variable_set("@#{k.to_s}", v) }
+        clone
+      end
   end
 end

data/lib/active_force/sobject.rb

@@ -129,6 +129,14 @@ module ActiveForce
       new(args).create!
     end
 
+    def self.update(id, attributes)
+      new(attributes.merge(id: id)).update
+    end
+
+    def self.update!(id, attributes)
+      new(attributes.merge(id: id)).update!
+    end
+
     def save!
       run_callbacks :save do
         if persisted?
@@ -231,7 +239,7 @@ module ActiveForce
     end
 
     def default_attributes
-      @attributes.each_value.select do |value| 
+      @attributes.each_value.select do |value|
         value.is_a?(ActiveModel::Attribute::UserProvidedDefault) || value.instance_values["original_attribute"].is_a?(ActiveModel::Attribute::UserProvidedDefault)
       end.map(&:name)
     end

data/lib/active_force/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveForce
-  VERSION = '0.16.0'
+  VERSION = '0.18.0'
 end

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
     [
@@ -18,7 +18,6 @@ describe ActiveForce::ActiveQuery do
     ]
   end
 
-
   before do
     allow(active_query).to receive(:sfdc_client).and_return client
     allow(active_query).to receive(:build).and_return Object.new
@@ -40,50 +39,113 @@ describe ActiveForce::ActiveQuery do
     end
   end
 
+  describe '#blank? delegation' do
+    before do
+      allow(client).to receive(:query).and_return(api_result)
+    end
+
+    context 'when there are no records' do
+      let(:api_result) { [] }
+
+      it 'returns true' do
+        result = active_query.where("Text_Label = 'foo'").blank?
+        expect(result).to be true
+      end
+    end
+
+    context 'when records are returned' do
+      it 'returns false' do
+        result = active_query.where("Text_Label = 'foo'").blank?
+        expect(result).to be false
+      end
+    end
+  end
+
+  describe '#present? delegation' do
+    before do
+      allow(client).to receive(:query).and_return(api_result)
+    end
+
+    context 'when there are no records' do
+      let(:api_result) { [] }
+
+      it 'returns false' do
+        result = active_query.where("Text_Label = 'foo'").present?
+        expect(result).to be false
+      end
+    end
+
+    context 'when there are records' do
+      it 'returns true' do
+        result = active_query.where("Text_Label = 'foo'").present?
+        expect(result).to be true
+      end
+    end
+  end
+
+  describe '#any? delegation' do
+    before do
+      allow(client).to receive(:query).and_return(api_result)
+    end
+
+    context 'when there are no records' do
+      let(:api_result) { [] }
+
+      it 'returns true' do
+        result = active_query.where("Text_Label = 'foo'").any?
+        expect(result).to be false
+      end
+    end
+
+    context 'when records are returned' do
+      it 'returns false' do
+        result = active_query.where("Text_Label = 'foo'").any?
+        expect(result).to be true
+      end
+    end
+  end
+
   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 +157,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 +194,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 +257,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 +397,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')"

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,17 +147,51 @@ 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'
+    context 'without any argument' 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
+
+    context 'with an argument' do
+      let(:last_argument) { 3 }
+
+      it 'should return the query for the last n records' do
+        expect(query.last(last_argument).to_s).to eq "SELECT Id, name, etc FROM table_name ORDER BY Id DESC LIMIT #{last_argument}"
+      end
+
+      it "should not update the original query" do
+        new_query = query.last last_argument
+        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 #{last_argument}"
+      end
     end
   end
 
@@ -138,6 +203,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

data/spec/active_force/sobject/includes_spec.rb

@@ -225,6 +225,13 @@ module ActiveForce
           end
         end
 
+        context 'when assocation has a scope' do
+          it 'formulates the correct SOQL query with the scope applied' do
+            soql = Post.includes(:impossible_comments).where(id: '1234').to_s
+            expect(soql).to eq "SELECT Id, Title__c, BlogId, (SELECT Id, PostId, PosterId__c, FancyPostId, Body__c FROM Comments__r WHERE (1 = 0)) FROM Post__c WHERE (Id = '1234')"
+          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
@@ -286,9 +293,26 @@ module ActiveForce
         end
       end
 
+      context 'has_one' do
+        context 'when assocation has a scope' do
+          it 'formulates the correct SOQL query with the scope applied' do
+            soql = Post.includes(:last_comment).where(id: '1234').to_s
+            expect(soql).to eq "SELECT Id, Title__c, BlogId, (SELECT Id, PostId, PosterId__c, FancyPostId, Body__c FROM Comment__r WHERE (NOT ((Body__c = NULL))) ORDER BY CreatedDate DESC) FROM Post__c WHERE (Id = '1234')"
+          end
+        end
+
+      end
+
       context 'when invalid associations are passed' do
-        it 'raises an error' do
-          expect { Quota.includes(:invalid).find('123') }.to raise_error(ActiveForce::Association::InvalidAssociationError, 'Association named invalid was not found on Quota')
+        context 'when the association is not defined' do
+          it 'raises an error' do
+            expect { Quota.includes(:invalid).find('123') }.to raise_error(ActiveForce::Association::InvalidAssociationError, 'Association named invalid was not found on Quota')
+          end
+        end
+        context 'when the association is scoped and accepts an argument' do
+          it 'raises and error' do
+            expect { Post.includes(:reply_comments).find('1234')}.to raise_error(ActiveForce::Association::InvalidEagerLoadAssociation)
+          end
         end
       end
     end

data/spec/active_force/sobject_spec.rb

@@ -313,20 +313,87 @@ describe ActiveForce::SObject do
         expect(Whizbang.create(text: 'some text')).to be_instance_of(Whizbang)
       end
     end
+
+    describe 'self.update' do
+      it 'uses the client to update the correct record' do
+        expect(client).to receive(:update!)
+          .with(Whizbang.table_name, { 'Id' => '12345678', 'Text_Label' => 'my text', 'Updated_From__c' => 'Rails' })
+          .and_return(true)
+        Whizbang.update('12345678', text: 'my text')
+      end
+    end
+
+    describe 'self.update!' do
+      it 'uses the client to update the correct record' do
+        expect(client).to receive(:update!)
+          .with(Whizbang.table_name, { 'Id' => '123456789', 'Text_Label' => 'some other text', 'Updated_From__c' => 'Rails' })
+          .and_return(true)
+        Whizbang.update('123456789', text: 'some other text')
+      end
+    end
   end
 
-  describe "#count" do
-    let(:count_response){ [Restforce::Mash.new(expr0: 1)] }
+  describe '.count' do
+    let(:response) { [Restforce::Mash.new(expr0: 1)] }
+
+    before do
+      allow(client).to receive(:query).and_return(response)
+    end
 
-    it "responds to count" do
-      expect(Whizbang).to respond_to(:count)
+    it 'sends the correct query to the client' do
+      expected = 'SELECT count(Id) FROM Whizbang__c'
+      Whizbang.count
+      expect(client).to have_received(:query).with(expected)
     end
 
-    it "sends the query to the client" do
-      expect(client).to receive(:query).and_return(count_response)
+    it 'returns the result from the response' do
       expect(Whizbang.count).to eq(1)
     end
 
+    it 'works with .where' do
+      expected = 'SELECT count(Id) FROM Whizbang__c WHERE (Boolean_Label = true)'
+      Whizbang.where(boolean: true).count
+      expect(client).to have_received(:query).with(expected)
+    end
+  end
+
+  describe '.sum' do
+    let(:response) { [Restforce::Mash.new(expr0: 22)] }
+
+    before do
+      allow(client).to receive(:query).and_return(response)
+    end
+
+    it 'raises ArgumentError if given blank' do
+      expect { Whizbang.sum(nil) }.to raise_error(ArgumentError, 'field is required')
+    end
+
+    it 'raises ArgumentError if given invalid field' do
+      expect { Whizbang.sum(:invalid) }
+        .to raise_error(ArgumentError, /field 'invalid' does not exist on Whizbang/i)
+    end
+
+    it 'sends the correct query to the client' do
+      expected = 'SELECT sum(Percent_Label) FROM Whizbang__c'
+      Whizbang.sum(:percent)
+      expect(client).to have_received(:query).with(expected)
+    end
+
+    it 'works when given a string field' do
+      expected = 'SELECT sum(Percent_Label) FROM Whizbang__c'
+      Whizbang.sum('percent')
+      expect(client).to have_received(:query).with(expected)
+    end
+
+    it 'returns the result from the response' do
+      expect(Whizbang.sum(:percent)).to eq(22)
+    end
+
+    it 'works with .where' do
+      expected = 'SELECT sum(Percent_Label) FROM Whizbang__c WHERE (Boolean_Label = true)'
+      Whizbang.where(boolean: true).sum(:percent)
+      expect(client).to have_received(:query).with(expected)
+    end
   end
 
   describe "#find_by" do

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: active_force
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 0.18.0
 platform: ruby
 authors:
 - Eloy Espinaco
 - Pablo Oldani
 - Armando Andini
 - José Piccioni
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-07-31 00:00:00.000000000 Z
+date: 2023-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -193,7 +193,7 @@ metadata:
   bug_tracker_uri: https://github.com/Beyond-Finance/active_force/issues
   changelog_uri: https://github.com/Beyond-Finance/active_force/blob/main/CHANGELOG.md
   source_code_uri: https://github.com/Beyond-Finance/active_force
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -208,8 +208,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key: 
+rubygems_version: 3.3.26
+signing_key:
 specification_version: 4
 summary: Help you implement models persisting on Sales Force within Rails using RESTForce
 test_files: