active_force 0.20.1 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1fbcc63ac7ef2ec3ac8efdadd055a61ae8e98fe721473a054d9207d95bc495e
-  data.tar.gz: 838eebde842f1edcc4b2b2a879b1697aec7439852af0f563b9f6687760b57434
+  metadata.gz: acbf91e00afed35fd89a0dc1505ebb40d275883bca6aba9237dad7d554e10b7b
+  data.tar.gz: 488fe99179b48383967688ecbfc2c2f93f3f565ec177e972fb6e9ad5e68b5d8e
 SHA512:
-  metadata.gz: ec076a1ffc49293809ebb2c66445ca70b1e016c82be03f4bf6803a6482b18d014711caca4112f7875f8a76cf85b27d1381cb8ffd2a749f7c49b21f801f298af6
-  data.tar.gz: 24378ad367f6ff96edaa88a902c946d5d2f38f71e69d1745cc7d769b0cb1d70dec4752e5825774506985c47202ed15835268b3ad08b1d5d255f6dbfb34b24e44
+  metadata.gz: 1b29a58711a0d6b63c82604c1bc2f3bfdc9b06e435468016fa7055bdd8ace5c779d09d4f11fdc32e7292ffd8c41a5784698610c1a6184116044bfa77b1c93cb5
+  data.tar.gz: 1bb0165385e5f06c7767d9463842e9daf742e11184e7518b008142162f8fb46bb2d35d5a1ba8f64be702cf169f5d9a6a9bfb3b8a1e83331fc11114c2ae30846a

data/.github/workflows

@@ -0,0 +1,51 @@
+on:
+  pull_request:
+    types: [opened, reopened, synchronize]
+  pull_request_review_comment:
+    types: [created, edited, deleted]
+
+name: Metomic Scan
+
+jobs:
+  scan-secrets:
+    name: Scan For Secrets
+    runs-on: ubuntu-latest
+    steps:
+      - name: checkout-repo
+        uses: actions/checkout@v3
+        with:
+          ref: ${{ github.event.pull_request.head.sha }}
+
+      - name: authenticate-with-metomic
+        id: authenticate
+        continue-on-error: ${{ vars.METOMIC_FAIL_ON_CONNECTION_ERROR != 'TRUE' }}
+        run: |
+          curl -s --location --request GET '${{ vars.METOMIC_INTEGRATION_ENDPOINT }}/token' --header 'X-API-Key: ${{ secrets.METOMIC_API_TOKEN }}' -o .metomic_token.json
+          echo METOMIC_ACCESS_TOKEN=$(cat .metomic_token.json | jq -r -c '.accessToken') >> $GITHUB_OUTPUT
+          PASS=$(cat .metomic_token.json | jq -r -c '.accessToken // empty')
+          if [ -z "$PASS" ]; then
+            cat .metomic_token.json
+            echo ""
+            echo "FAIL: failed to fetch auth token from Metomic. Ensure required organisation variables / secrets are set correctly. METOMIC_INTEGRATION_ENDPOINT, METOMIC_API_TOKEN"
+            echo "The correct values for these variables are available from the installations page of the Metomic dashboard"
+            exit 1
+          fi
+
+      - name: checkout-metomic-action
+        id: checkout
+        uses: actions/checkout@v3
+        if: ${{ steps.authenticate.outcome == 'success' }}
+        continue-on-error: ${{ vars.METOMIC_FAIL_ON_CONNECTION_ERROR != 'TRUE' }}
+        with:
+          repository: metomic/metomic-github-integration-action.git
+          path: "./.metomic"
+          ref: "main"
+          token: ${{ steps.authenticate.outputs.METOMIC_ACCESS_TOKEN }}
+
+      - name: scan
+        uses: ./.metomic/.github/actions/scan-secrets
+        if: ${{ steps.authenticate.outputs.METOMIC_ACCESS_TOKEN && steps.checkout.outcome == 'success' }}
+        with:
+          metomic_endpoint: ${{ vars.METOMIC_INTEGRATION_ENDPOINT }}
+          metomic_api_token: ${{ secrets.METOMIC_API_TOKEN }}
+          head_ref: ${{ github.event.pull_request.head.sha }}

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.idea

data/CHANGELOG.md

@@ -2,7 +2,18 @@
 
 ## Not released
 
+## 0.21.0
+
+- Uninitialized attributes will ERROR instead of returning as `nil` (https://github.com/Beyond-Finance/active_force/pull/78)
+- Add Range condition support (https://github.com/Beyond-Finance/active_force/pull/87)
+- Use ':decimal' type for Salesforce currency fields in model generation (#88) (https://github.com/Beyond-Finance/active_force/pull/88)
+- Fix includes with has_one associations when no associated record (https://github.com/Beyond-Finance/active_force/pull/83)
+- Raise `UnknownFieldError` if `.where` is given non-existent attribute names (https://github.com/Beyond-Finance/active_force/pull/80)
+- Fix `.update` and `.update!`: include given `nil` valued attributes in request (https://github.com/Beyond-Finance/active_force/pull/79)
+- Change `.first` to not query the API if records have already been retrieved (https://github.com/Beyond-Finance/active_force/pull/77)
+
 ## 0.20.1
+
 - Revert "ActiveForce .first performance enhancement (#73)" (https://github.com/Beyond-Finance/active_force/pull/76)
 
 ## 0.20.0

data/README.md

@@ -186,6 +186,17 @@ Account.where(contact_by: 'web').or(Account.where(contact_by: 'email'))
 #                    OR (contact_by__c = 'email')"
 ```
 
+You can use Ranges to specify comparisons:
+
+```ruby
+Account.where(last_activity_date: Date.new(2023, 1, 1)...Date.new(2024, 1, 1))
+       .where(annual_revenue: 1_000..)
+#=> this will query "SELECT Id, Name...
+#                    FROM Account
+#                    WHERE (LastActivityDate >= 2023-01-01) AND (LastActivityDate < 2024-01-01)
+#                    AND (AnnualRevenue >= 1000)
+```
+
 It is also possible to eager load associations:
 
 ```ruby

data/lib/active_force/active_query.rb

@@ -4,6 +4,13 @@ require 'forwardable'
 
 module ActiveForce
   class PreparedStatementInvalid < ArgumentError; end
+
+  class UnknownFieldError < StandardError
+    def initialize(object, field)
+      super("unknown field '#{field}' for #{object.name}")
+    end
+  end
+
   class RecordNotFound < StandardError
     attr_reader :table_name, :conditions
 
@@ -45,9 +52,9 @@ module ActiveForce
       sfdc_client.query(super.to_s).first.expr0
     end
 
-    def sum field
+    def sum(field)
       raise ArgumentError, 'field is required' if field.blank?
-      raise ArgumentError, "field '#{field}' does not exist on #{sobject}" unless mappings.key?(field.to_sym)
+      raise UnknownFieldError.new(sobject, field) unless mappings.key?(field.to_sym)
 
       sfdc_client.query(super(mappings.fetch(field.to_sym)).to_s).first.expr0
     end
@@ -56,6 +63,10 @@ module ActiveForce
       limit == 1 ? super.to_a.first : super
     end
 
+    def first
+      super.to_a.first
+    end
+
     def not args=nil, *rest
       return self if args.nil?
 
@@ -162,16 +173,21 @@ module ActiveForce
     end
 
     def build_conditions_from_hash(hash)
-      hash.map do |key, value|
-        applicable_predicate mappings[key], value
+      hash.flat_map do |key, value|
+        field = mappings[key]
+        raise UnknownFieldError.new(sobject, key) if field.blank?
+
+        applicable_predicates(field, value)
       end
     end
 
-    def applicable_predicate(attribute, value)
-      if value.is_a? Array
-        in_predicate attribute, value
+    def applicable_predicates(attribute, value)
+      if value.is_a?(Array)
+        [in_predicate(attribute, value)]
+      elsif value.is_a?(Range)
+        range_predicates(attribute, value)
       else
-        eq_predicate attribute, value
+        [eq_predicate(attribute, value)]
       end
     end
 
@@ -184,6 +200,16 @@ module ActiveForce
       "#{attribute} = #{enclose_value value}"
     end
 
+    def range_predicates(attribute, range)
+      conditions = []
+      conditions << "#{attribute} >= #{enclose_value(range.begin)}" unless range.begin.nil?
+      unless range.end.nil?
+        operator = range.exclude_end? ? '<' : '<='
+        conditions << "#{attribute} #{operator} #{enclose_value(range.end)}"
+      end
+      conditions
+    end
+
     def enclose_value value
       case value
       when String

data/lib/active_force/association/relation_model_builder.rb

@@ -50,7 +50,11 @@ module ActiveForce
 
     class BuildFromArray < AbstractBuildFrom
       def call
-        value.map { |mash| association.build(mash, association_mapping) }
+        if association.is_a?(HasOneAssociation)
+          association.build(value.first, association_mapping)
+        else
+          value.map { |mash| association.build(mash, association_mapping) }
+        end
       end
     end
 

data/lib/active_force/query.rb

@@ -78,7 +78,15 @@ module ActiveForce
     end
 
     def first
-      limit 1
+      if @records
+        clone_and_set_instance_variables(
+          size: 1,
+          records: [@records.first],
+          decorated_records: [@decorated_records&.first]
+        )
+      else
+        clone_and_set_instance_variables(size: 1)
+      end
     end
 
     def last(limit = 1)
@@ -126,9 +134,9 @@ module ActiveForce
 
       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) }
+        { decorated_records: nil, records: nil }
+          .merge(instance_variable_hash)
+          .each { |k,v| clone.instance_variable_set("@#{k.to_s}", v) }
         clone
       end
   end

data/lib/active_force/sobject.rb

@@ -7,6 +7,7 @@ require 'yaml'
 require 'forwardable'
 require 'logger'
 require 'restforce'
+require 'active_model/attribute/uninitialized_value'
 
 module ActiveForce
   class RecordInvalid < StandardError;end
@@ -34,8 +35,24 @@ module ActiveForce
       def_delegators :query, :not, :or, :where, :first, :last, :all, :find, :find!, :find_by, :find_by!, :sum, :count, :includes, :limit, :order, :select, :none
       def_delegators :mapping, :table, :table_name, :custom_table?, :mappings
 
+      def update(id, attributes)
+        prepare_for_update(id, attributes).update
+      end
+
+      def update!(id, attributes)
+        prepare_for_update(id, attributes).update!
+      end
+
       private
 
+      def prepare_for_update(id, attributes)
+        new(attributes.merge(id: id)).tap do |obj|
+          attributes.each do |name, value|
+            obj.public_send("#{name}_will_change!") if value.nil?
+          end
+        end
+      end
+
       ###
       # Provide each subclass with a default id field. Can be overridden
       # in the subclass if needed
@@ -64,6 +81,9 @@ module ActiveForce
     def self.build mash, association_mapping={}
       return unless mash
       sobject = new
+
+      attributes_not_selected = sobject.class.fields.reject{|key| mash.keys.include?(key)}
+      sobject.uninitialize_attributes(attributes_not_selected)
       sobject.build_attributes = mash[:build_attributes] || mash
       sobject.run_callbacks(:build) do
         mash.each do |column, value|
@@ -110,6 +130,17 @@ module ActiveForce
       self
     end
 
+    def uninitialize_attributes(attrs)
+      return if attrs.blank?
+      self.instance_variable_get(:@attributes).instance_variable_get(:@attributes).each do |key, value|
+        if attrs.include?(self.mappings.dig(value.name.to_sym))
+          self.instance_variable_get(:@attributes).instance_variable_get(:@attributes)[key] = ActiveModel::Attribute::UninitializedValue.new(value.name, value.type)
+        else
+          key
+        end
+      end
+    end
+
     def create
       create!
     rescue Faraday::ClientError, RecordInvalid => error
@@ -131,14 +162,6 @@ 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?
@@ -183,18 +206,12 @@ module ActiveForce
       self
     end
 
-    def write_value key, value, association_mapping = {}
-      if association = self.class.find_association(key.to_sym)
-        field = association.relation_name
-        value = Association::RelationModelBuilder.build(association, value, association_mapping)
-      elsif key.to_sym.in?(mappings.keys)
-        # key is a field name
-        field = key
+    def write_value(key, value, association_mapping = {})
+      if (association = self.class.find_association(key.to_sym))
+        write_association_value(association, value, association_mapping)
       else
-        # Assume key is an SFDC column
-        field = mappings.key(key)
+        write_field_value(key, value)
       end
-      send "#{field}=", value if field && respond_to?(field)
     end
 
     def [](name)
@@ -205,7 +222,7 @@ module ActiveForce
       send("#{name.to_sym}=", value)
     end
 
-   private
+    private
 
     def validate!
       unless valid?
@@ -215,6 +232,21 @@ module ActiveForce
       end
     end
 
+    def write_association_value(association, value, association_mapping)
+      association_cache[association.relation_name] = Association::RelationModelBuilder.build(association, value,
+                                                                                             association_mapping)
+    end
+
+    def write_field_value(field_key, value)
+      field = if mappings.key?(field_key.to_sym)
+                field_key
+              else
+                mappings.key(field_key)
+              end
+
+      send("#{field}=", value) if field && respond_to?(field)
+    end
+
     def handle_save_error error
       return false if error.class == RecordInvalid
       logger_output __method__, error, attributes

data/lib/active_force/version.rb

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

data/lib/active_model/attribute/uninitialized_value.rb

@@ -0,0 +1,12 @@
+require 'active_model'
+
+module ActiveModel
+  class Attribute
+    class UninitializedValue < Uninitialized # :nodoc:
+
+      def value
+        raise ActiveModel::MissingAttributeError, "missing attribute: #{name}"
+      end
+    end
+  end
+end

data/lib/generators/active_force/model/model_generator.rb

@@ -9,7 +9,7 @@ module ActiveForce
       'boolean' => :boolean,
       'double' => :float,
       'percentage' => :float,
-      'currency' => :float,
+      'currency' => :decimal,
       'date' => :date,
       'datetime' => :datetime,
       'int' => :integer,

data/spec/active_force/active_query_spec.rb

@@ -1,12 +1,17 @@
 require 'spec_helper'
 
+class TestSObject < ActiveForce::SObject
+  def self.decorate(records)
+    records
+  end
+end
+
 describe ActiveForce::ActiveQuery do
   let(:sobject) do
-    double("sobject", {
-      table_name: "table_name",
-      fields: [],
-      mappings: mappings
-    })
+    class_double(
+      TestSObject,
+      { table_name: 'table_name', fields: [], mappings: mappings, name: 'TableName' }
+    )
   end
   let(:mappings){ { id: "Id", field: "Field__c", other_field: "Other_Field" } }
   let(:client) { double('client', query: nil) }
@@ -148,6 +153,74 @@ describe ActiveForce::ActiveQuery do
       expect(new_query.to_s).to end_with("(Field__c = NULL)")
     end
 
+    describe 'range filter' do
+      def check_endless(query, start, field: 'Field__c')
+        expect(query.to_s).to end_with("(#{field} >= #{start})")
+      end
+
+      def check_beginless_inclusive(query, finish, field: 'Field__c')
+        expect(query.to_s).to end_with("(#{field} <= #{finish})")
+      end
+
+      def check_beginless_exclusive(query, finish, field: 'Field__c')
+        expect(query.to_s).to end_with("(#{field} < #{finish})")
+      end
+
+      def check_inclusive(query, start, finish, field: 'Field__c')
+        expect(query.to_s).to end_with("(#{field} >= #{start}) AND (#{field} <= #{finish})")
+      end
+
+      def check_exclusive(query, start, finish, field: 'Field__c')
+        expect(query.to_s).to end_with("(#{field} >= #{start}) AND (#{field} < #{finish})")
+      end
+
+      def check_ranges(base_query, start, finish, &format_block)
+        formatted_start = format_block&.call(start) || start.to_s
+        formatted_finish = format_block&.call(finish) || finish.to_s
+        check_endless(base_query.where(field: start..), formatted_start)
+        check_beginless_inclusive(base_query.where(field: ..finish), formatted_finish)
+        check_beginless_exclusive(base_query.where(field: ...finish), formatted_finish)
+        check_inclusive(base_query.where(field: start..finish), formatted_start, formatted_finish)
+        check_exclusive(base_query.where(field: start...finish), formatted_start, formatted_finish)
+      end
+
+      it 'renders with Dates' do
+        check_ranges(active_query, Date.new(2024, 2, 2), Date.new(2024, 2, 28))
+      end
+
+      it 'renders with DateTimes' do
+        check_ranges(active_query, DateTime.new(2024, 1, 31, 1, 2, 3), DateTime.new(2024, 1, 31, 1, 2, 4))
+      end
+
+      it 'renders with Times' do
+        check_ranges(active_query, Time.current, Time.current + 1.hour, &:iso8601)
+      end
+
+      it 'renders with Strings' do
+        check_ranges(active_query, 'a', 'z') { |x| "'#{x}'"}
+      end
+
+      it 'renders with Integers' do
+        check_ranges(active_query, 1, 99)
+      end
+
+      it 'renders with Floats' do
+        check_ranges(active_query, 0.5, 100.89)
+      end
+
+      it 'renders with BigDecimal' do
+        check_ranges(active_query, BigDecimal('0.888'), BigDecimal('11.0003'))
+      end
+
+      it 'composes with other conditions' do
+        query = active_query.where(id: 'id1'.., field: 1..99, other_field: 'a')
+                            .not(id: 'id2')
+        expect(query.to_s).to end_with(
+          "(Id >= 'id1') AND (Field__c >= 1) AND (Field__c <= 99) AND (Other_Field = 'a') AND (NOT ((Id = 'id2')))"
+          )
+      end
+    end
+
     describe 'bind parameters' do
       let(:mappings) do
         super().merge({
@@ -296,6 +369,13 @@ describe ActiveForce::ActiveQuery do
         end
       end
     end
+
+    context 'when given attributes Hash with fields that do not exist on the SObject' do
+      it 'raises UnknownFieldError' do
+        expect { active_query.where(xyz: 1) }
+          .to raise_error(ActiveForce::UnknownFieldError, /unknown field 'xyz' for #{sobject.name}/i)
+      end
+    end
   end
 
   describe '#not' do
@@ -329,6 +409,11 @@ describe ActiveForce::ActiveQuery do
       new_query = active_query.find_by field: 123
       expect(new_query).to be_nil
     end
+
+    it 'should raise UnknownFieldError if given invalid field' do
+      expect { active_query.find_by(invalid: true) }
+        .to raise_error(ActiveForce::UnknownFieldError, /unknown field 'invalid' for #{sobject.name}/i)
+    end
   end
 
   describe '#find_by!' do
@@ -337,6 +422,11 @@ describe ActiveForce::ActiveQuery do
       expect { active_query.find_by!(field: 123) }
         .to raise_error(ActiveForce::RecordNotFound, "Couldn't find #{sobject.table_name} with {:field=>123}")
     end
+
+    it 'should raise UnknownFieldError if given invalid field' do
+      expect { active_query.find_by!(invalid: true) }
+        .to raise_error(ActiveForce::UnknownFieldError, /unknown field 'invalid' for #{sobject.name}/i)
+    end
   end
 
   describe '#find!' do
@@ -463,4 +553,22 @@ describe ActiveForce::ActiveQuery do
    end
     
   end
+
+  describe '#first' do
+    before do
+      allow(client).to receive(:query).and_return(api_result)
+      api_result.each do |instance|
+        allow(active_query).to receive(:build).with(instance, {}).and_return(double(:sobject, id: instance['Id']))
+      end
+    end
+
+    it 'returns a single record when the api was already queried' do
+      active_query.to_a # this will simulate the api call as to_a executes the query and populates the records
+      expect(active_query.first.id).to eq("0000000000AAAAABBB")
+    end
+
+    it 'returns a single record when the api was not already queried' do
+      expect(active_query.first.id).to eq("0000000000AAAAABBB")
+    end
+  end
 end

data/spec/active_force/association/relation_model_builder_spec.rb

@@ -70,6 +70,36 @@ module ActiveForce
             end
           end
 
+          context 'with a restforce collection value' do
+            let(:value) do
+              build_restforce_collection([
+                                           build_restforce_sobject('Id' => 'first'),
+                                           build_restforce_sobject('Id' => 'second')
+                                         ])
+            end
+
+            it 'returns a child for the first value' do
+              actual = instance.build_relation_model
+              expect(actual).to be_a(HasOneChild)
+              expect(actual.id).to eq('first')
+            end
+          end
+
+          context 'with an array value' do
+            let(:value) do
+              [
+                build_restforce_sobject('Id' => 'first'),
+                build_restforce_sobject('Id' => 'second')
+              ]
+            end
+
+            it 'returns a child for the first value' do
+              actual = instance.build_relation_model
+              expect(actual).to be_a(HasOneChild)
+              expect(actual.id).to eq('first')
+            end
+          end
+
           context 'without a value' do
             let(:value){ nil }
 

data/spec/active_force/query_spec.rb

@@ -165,6 +165,22 @@ describe ActiveForce::Query do
       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
+
+    it "does not query if records have already been fetched" do
+      query = ActiveForce::Query.new 'table_name'
+      query.instance_variable_set(:@records, %w[foo bar])
+      query.instance_variable_set(:@decorated_records, %w[foo bar])
+      expect(query).not_to receive(:clone_and_set_instance_variables).with(size: 1)
+      expect(query).to receive(:clone_and_set_instance_variables).with(size: 1, records: ['foo'], decorated_records: ['foo'])
+      query.first
+    end
+
+    it 'queries the api if it has not been queried yet' do
+      query = ActiveForce::Query.new 'table_name'
+      query.instance_variable_set(:@records, nil)
+      expect(query).to receive(:clone_and_set_instance_variables).with(size: 1)
+      query.first
+    end
   end
 
   describe '.last' do

data/spec/active_force/sobject/includes_spec.rb

@@ -301,6 +301,45 @@ module ActiveForce
           end
         end
 
+        context 'when query returns nil for associated record' do
+          let(:response) do
+            [build_restforce_sobject({ 'Id' => '123', 'Membership__r' => nil })]
+          end
+
+          before do
+            allow(client).to receive(:query).and_return(response)
+          end
+
+          it 'the association method returns nil without making another request' do
+            member = ClubMember.includes(:membership).where(id: '123').first
+            membership = member.membership
+            expect(membership).to be_nil
+            expect(client).to have_received(:query).once
+          end
+        end
+      end
+
+      context 'when query returns an associated record' do
+        let(:response) do
+          [
+            build_restforce_sobject(
+              {
+                'Id' => '123',
+                'Membership__r' => build_restforce_collection([build_restforce_sobject({ 'Id' => '33' })])
+              }
+            )
+          ]
+        end
+
+        before do
+          allow(client).to receive(:query).and_return(response)
+        end
+
+        it 'the association method returns the record without making another request' do
+          member = ClubMember.includes(:membership).where(id: '123').first
+          expect(member.membership.id).to eq('33')
+          expect(client).to have_received(:query).once
+        end
       end
 
       context 'when invalid associations are passed' do

data/spec/active_force/sobject/select_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+module ActiveForce
+  describe SObject do
+    let(:client){ double "client" }
+
+    before do
+      ActiveForce.sfdc_client = client
+    end
+
+    describe '.select' do
+      it 'has correct fields in query' do
+        query = Territory.select(:name, :id)
+        expect(query.fields).to eq(["Name", "Id"])
+      end
+
+      context 'when getting the value of an uninitialized attribute' do
+        let(:territory) { Territory.select(:id).first }
+        let(:response) do
+          [build_restforce_sobject({
+            "Id"       => "123",
+            "Quota__c" => "321",
+          })]
+        end
+
+        before do
+          allow(client).to receive(:query).once.and_return response
+        end
+
+        it 'raises missing attribute error if uninitialized variable is called' do
+          expect{territory.name}.to raise_error(ActiveModel::MissingAttributeError)
+        end
+
+        it 'returns SObjects with Uninitialized Value' do
+          expect(territory.instance_variable_get(:@attributes)["name"]).to be_an_instance_of(ActiveModel::Attribute::UninitializedValue)
+        end
+      end
+    end
+  end
+end

data/spec/active_force/sobject_spec.rb

@@ -321,6 +321,15 @@ describe ActiveForce::SObject do
           .and_return(true)
         Whizbang.update('12345678', text: 'my text')
       end
+
+      it 'includes given nil values in the request' do
+        allow(client).to receive(:update!).and_return(true)
+        Whizbang.update('test123', text: nil, date: nil)
+        expect(client).to have_received(:update!).with(
+          Whizbang.table_name,
+          { 'Id' => 'test123', 'Text_Label' => nil, 'Date_Label' => nil, 'Updated_From__c' => 'Rails' }
+        )
+      end
     end
 
     describe 'self.update!' do
@@ -330,6 +339,15 @@ describe ActiveForce::SObject do
           .and_return(true)
         Whizbang.update('123456789', text: 'some other text')
       end
+
+      it 'includes given nil values in the request' do
+        allow(client).to receive(:update!).and_return(true)
+        Whizbang.update!('test123', text: nil, date: nil)
+        expect(client).to have_received(:update!).with(
+          Whizbang.table_name,
+          { 'Id' => 'test123', 'Text_Label' => nil, 'Date_Label' => nil, 'Updated_From__c' => 'Rails' }
+        )
+      end
     end
   end
 
@@ -368,9 +386,9 @@ describe ActiveForce::SObject do
       expect { Whizbang.sum(nil) }.to raise_error(ArgumentError, 'field is required')
     end
 
-    it 'raises ArgumentError if given invalid field' do
+    it 'raises UnknownFieldError if given invalid field' do
       expect { Whizbang.sum(:invalid) }
-        .to raise_error(ArgumentError, /field 'invalid' does not exist on Whizbang/i)
+        .to raise_error(ActiveForce::UnknownFieldError, /unknown field 'invalid' for Whizbang/i)
     end
 
     it 'sends the correct query to the client' do
@@ -401,6 +419,11 @@ describe ActiveForce::SObject do
       expect(client).to receive(:query).with("SELECT #{Whizbang.fields.join ', '} FROM Whizbang__c WHERE (Id = 123) AND (Text_Label = 'foo') LIMIT 1")
       Whizbang.find_by id: 123, text: "foo"
     end
+
+    it 'raises UnknownFieldError if given invalid field' do
+      expect { Whizbang.find_by(xyz: 1) }
+        .to raise_error(ActiveForce::UnknownFieldError, /unknown field 'xyz' for Whizbang/)
+    end
   end
 
   describe "#find_by!" do
@@ -408,10 +431,16 @@ describe ActiveForce::SObject do
       expect(client).to receive(:query).with("SELECT #{Whizbang.fields.join ', '} FROM Whizbang__c WHERE (Id = 123) AND (Text_Label = 'foo') LIMIT 1").and_return([Restforce::Mash.new(Id: 123, text: 'foo')])
       Whizbang.find_by! id: 123, text: "foo"
     end
+
     it "raises if nothing found" do
       expect(client).to receive(:query).with("SELECT #{Whizbang.fields.join ', '} FROM Whizbang__c WHERE (Id = 123) AND (Text_Label = 'foo') LIMIT 1")
       expect { Whizbang.find_by! id: 123, text: "foo" }.to raise_error(ActiveForce::RecordNotFound)
     end
+
+    it 'raises UnknownFieldError if given invalid field' do
+      expect { Whizbang.find_by!(xyz: 1) }
+        .to raise_error(ActiveForce::UnknownFieldError, /unknown field 'xyz' for Whizbang/)
+    end
   end
 
   describe '.find!' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_force
 version: !ruby/object:Gem::Version
-  version: 0.20.1
+  version: 0.21.0
 platform: ruby
 authors:
 - Eloy Espinaco
@@ -11,7 +11,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-29 00:00:00.000000000 Z
+date: 2024-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -134,6 +134,7 @@ files:
 - ".circleci/config.yml"
 - ".github/ISSUE_TEMPLATE/bug_report.md"
 - ".github/ISSUE_TEMPLATE/feature_request.md"
+- ".github/workflows"
 - ".gitignore"
 - ".mailmap"
 - ".rspec"
@@ -166,6 +167,7 @@ files:
 - lib/active_force/standard_types.rb
 - lib/active_force/table.rb
 - lib/active_force/version.rb
+- lib/active_model/attribute/uninitialized_value.rb
 - lib/active_model/type/salesforce/multipicklist.rb
 - lib/active_model/type/salesforce/percent.rb
 - lib/generators/active_force/model/USAGE
@@ -183,6 +185,7 @@ files:
 - spec/active_force/mapping_spec.rb
 - spec/active_force/query_spec.rb
 - spec/active_force/sobject/includes_spec.rb
+- spec/active_force/sobject/select_spec.rb
 - spec/active_force/sobject/table_name_spec.rb
 - spec/active_force/sobject_spec.rb
 - spec/active_force/table_spec.rb
@@ -216,7 +219,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Help you implement models persisting on Sales Force within Rails using RESTForce
@@ -233,6 +236,7 @@ test_files:
 - spec/active_force/mapping_spec.rb
 - spec/active_force/query_spec.rb
 - spec/active_force/sobject/includes_spec.rb
+- spec/active_force/sobject/select_spec.rb
 - spec/active_force/sobject/table_name_spec.rb
 - spec/active_force/sobject_spec.rb
 - spec/active_force/table_spec.rb