Test updates

Author: fspeirs

spec/jobs/salesforce/school_sync_job_spec.rb

@@ -5,77 +5,68 @@
 RSpec.describe Salesforce::SchoolSyncJob do
   subject(:perform_job) { described_class.perform_now(school_id: school.id) }
 
-  context 'when the job has run' do
-    let(:school) { create(:school) }
-    let(:sf_school) { Salesforce::School.find(school.id) }
+  let(:school) { create(:school) }
+  let(:sf_school) { instance_double(Salesforce::School) }
+  let(:synced_attributes) { {} }
+
+  before do
+    allow(Salesforce::School).to receive(:find_or_initialize_by).with(editoruuid__c: school.id).and_return(sf_school)
+    allow(sf_school).to receive(:attributes=) { |attrs| synced_attributes.merge!(attrs) }
+    allow(sf_school).to receive(:save!)
+  end
 
+  context 'when the job has run' do
     before { perform_job }
 
-    it 'syncs the standard mappings' do
-      described_class::FIELD_MAPPINGS.each do |sf_field, field|
-        sf_value = sf_school.send(sf_field)
-        school_value = school.send(field)
-        column = Salesforce::School.column_for_attribute(sf_field)
-        ar_type = Salesforce::School.type_for_attribute(sf_field.to_s)
-
-        expected = if school_value.is_a?(String) && column.limit
-                     school_value.truncate(column.limit, omission: '…')
-                   else
-                     ar_type.cast(school_value)
-                   end
-
-        expect(sf_value).to eq(expected), "Expected #{sf_field} to be #{expected.inspect} but was #{sf_value.inspect}"
+    it 'syncs all FIELD_MAPPINGS to the correct school values' do
+      described_class::FIELD_MAPPINGS.each do |sf_field, school_field|
+        expect(synced_attributes[sf_field]).to eq(school.send(school_field)),
+          "Expected #{sf_field} to equal school.#{school_field}"
       end
     end
 
-    context 'when address fields are very long' do
-      let(:max_field_size) { Salesforce::School.column_for_attribute(:addressline1__c).limit }
-      let(:school) { create(:school, address_line_1: '❌' * (max_field_size + 10)) }
+    it 'saves the Salesforce record' do
+      expect(sf_school).to have_received(:save!)
+    end
+
+    context 'when an address field is very long' do
+      let(:school) { create(:school, address_line_1: '❌' * 300) }
 
-      it 'truncates addressline1__c to the max field length' do
-        expect(sf_school.addressline1__c.size).to be <= max_field_size
+      it 'truncates addressline1__c' do
+        expect(synced_attributes[:addressline1__c]).to end_with('…')
+        expect(synced_attributes[:addressline1__c].length).to be < school.address_line_1.length
       end
     end
 
     context 'when the school is verified' do
       let(:school) { create(:verified_school) }
 
       it 'syncs verifiedat__c' do
-        expect(sf_school.verifiedat__c).to eq(school.verified_at)
+        expect(synced_attributes[:verifiedat__c]).to eq(school.verified_at)
       end
     end
 
     context 'when the school is rejected' do
       let(:school) { create(:school, rejected_at: Time.current) }
 
       it 'syncs rejectedat__c' do
-        expect(sf_school.rejectedat__c).to eq(school.rejected_at)
+        expect(synced_attributes[:rejectedat__c]).to eq(school.rejected_at)
       end
     end
   end
 
   context 'when the Salesforce school fails to save' do
-    let(:school) { create(:school) }
-    let(:sf_school) { instance_double(Salesforce::School) }
-
-    before do
-      allow(Salesforce::School).to receive(:find_or_initialize_by).with(editoruuid__c: school.id).and_return(sf_school)
-      allow(sf_school).to receive(:attributes=)
-      allow(sf_school).to receive(:save!).and_raise(ActiveRecord::RecordInvalid)
-    end
+    before { allow(sf_school).to receive(:save!).and_raise(ActiveRecord::RecordInvalid) }
 
     it 'raises an error' do
       expect { perform_job }.to raise_error ActiveRecord::RecordInvalid
     end
   end
 
   context 'when SALESFORCE_ENABLED is false' do
-    let(:school) { create(:school) }
-
     before { stub_const('ENV', ENV.to_h.merge('SALESFORCE_ENABLED' => 'false')) }
 
     it 'discards the job without syncing' do
-      allow(Salesforce::School).to receive(:find_or_initialize_by)
       perform_job
       expect(Salesforce::School).not_to have_received(:find_or_initialize_by)
     end