restforce-db 2.5.0 → 2.6.0

data/test/lib/restforce/db/model_test.rb

@@ -4,25 +4,97 @@ describe Restforce::DB::Model do
 
   configure!
 
-  let(:database_model) { CustomObject }
-  let(:salesforce_model) { "CustomObject__c" }
+  describe "given a database model which includes the module" do
+    let(:database_model) { CustomObject }
+    let(:salesforce_model) { "CustomObject__c" }
 
-  before do
-    database_model.send(:include, Restforce::DB::Model)
-  end
-
-  describe ".sync_with" do
     before do
-      database_model.sync_with(salesforce_model) do
-        maps(
-          name:    "Name",
-          example: "Example_Field__c",
-        )
+      database_model.send(:include, Restforce::DB::Model)
+    end
+
+    describe ".sync_with" do
+      before do
+        database_model.sync_with(salesforce_model) do
+          maps(
+            name:    "Name",
+            example: "Example_Field__c",
+          )
+        end
+      end
+
+      it "adds a mapping to the global Restforce::DB::Registry" do
+        expect(Restforce::DB::Registry[database_model]).to_not_be :empty?
       end
     end
 
-    it "adds a mapping to the global Restforce::DB::Registry" do
-      expect(Restforce::DB::Registry[database_model]).to_not_be :empty?
+    describe "#force_sync!", :vcr do
+      let(:mapping) { Restforce::DB::Registry[database_model].first }
+
+      before do
+        database_model.sync_with(salesforce_model) do
+          maps(
+            name:    "Name",
+            example: "Example_Field__c",
+          )
+        end
+      end
+
+      describe "given an unpersisted record for a mapped model" do
+        let(:record) { database_model.new }
+
+        it "does nothing" do
+          expect(record.force_sync!).to_equal false
+        end
+      end
+
+      describe "given an unsynchronized record for a mapped model" do
+        let(:record) { database_model.create!(attributes) }
+        let(:attributes) do
+          {
+            name: "Frederick's Flip-flop",
+            example: "Yes, we only have the left one.",
+          }
+        end
+
+        before do
+          expect(record.force_sync!).to_equal true
+          Salesforce.records << [salesforce_model, record.salesforce_id]
+        end
+
+        it "creates a matching record in Salesforce" do
+          salesforce_record = mapping.salesforce_record_type.find(
+            record.salesforce_id,
+          ).record
+
+          expect(salesforce_record.Name).to_equal attributes[:name]
+          expect(salesforce_record.Example_Field__c).to_equal attributes[:example]
+        end
+      end
+
+      describe "given a previously-synchronized record for a mapped model" do
+        let(:attributes) do
+          {
+            name: "Sally's Seashells",
+            example: "She sells them down by the seashore.",
+          }
+        end
+        let(:salesforce_id) do
+          Salesforce.create!(
+            salesforce_model,
+            "Name" => attributes[:name],
+            "Example_Field__c" => attributes[:example],
+          )
+        end
+        let(:record) { database_model.create!(attributes.merge(salesforce_id: salesforce_id)) }
+
+        it "force-updates both synchronized records" do
+          record.update!(name: "Sarah's Seagulls")
+          expect(record.force_sync!).to_equal true
+
+          salesforce_record = mapping.salesforce_record_type.find(salesforce_id).record
+          expect(salesforce_record.Name).to_equal record.name
+        end
+      end
     end
   end
 

data/test/lib/restforce/db/timestamp_cache_test.rb

@@ -8,8 +8,9 @@ describe Restforce::DB::TimestampCache do
 
   let(:timestamp) { Time.now }
   let(:id) { "some-id" }
-  let(:instance_class) { Struct.new(:id, :last_update) }
-  let(:instance) { instance_class.new(id, timestamp) }
+  let(:record_type) { "CustomObject__c" }
+  let(:instance_class) { Struct.new(:id, :record_type, :last_update) }
+  let(:instance) { instance_class.new(id, record_type, timestamp) }
 
   describe "#cache_timestamp" do
     before { cache.cache_timestamp instance }
@@ -20,7 +21,7 @@ describe Restforce::DB::TimestampCache do
   end
 
   describe "#changed?" do
-    let(:new_instance) { instance_class.new(id, timestamp) }
+    let(:new_instance) { instance_class.new(id, record_type, timestamp) }
 
     describe "when the passed instance was not internally updated" do
       before do
@@ -57,7 +58,7 @@ describe Restforce::DB::TimestampCache do
       end
 
       describe "and a stale timestamp is cached" do
-        let(:new_instance) { instance_class.new(id, timestamp + 1) }
+        let(:new_instance) { instance_class.new(id, record_type, timestamp + 1) }
         before { cache.cache_timestamp instance }
 
         it "returns true" do

data/test/lib/restforce/db/worker_test.rb

@@ -0,0 +1,63 @@
+require_relative "../../../test_helper"
+
+describe Restforce::DB::Worker do
+
+  configure!
+  mappings!
+
+  let(:worker) { Restforce::DB::Worker.new(delay: 0) }
+  let(:runner) { worker.send(:runner) }
+
+  describe "a race condition during synchronization", vcr: { match_requests_on: [:method, VCR.request_matchers.uri_without_param(:q)] } do
+    let(:database_record) { mapping.database_model.create! }
+    let(:new_name) { "A New User-Entered Name" }
+
+    before do
+      # 0. A record is added to the database.
+      database_record
+
+      # 1. The first loop runs
+
+      ## 1b. The record is synced to Salesforce.
+      worker.send :reset!
+      worker.send :propagate, mapping
+      expect(database_record.reload).to_be :salesforce_id?
+      Salesforce.records << [salesforce_model, database_record.salesforce_id]
+
+      ## 1c. The database record is updated (externally) by a user.
+      database_record.update! name: new_name
+
+      # We stub `last_update` to get around issues with VCR's cached timestamp;
+      # we need the Salesforce record timestamp to be contemporary with this
+      # test run.
+      Restforce::DB::Instances::Salesforce.stub_any_instance(:last_update, Time.now) do
+
+        ## 1d. The record in Salesforce is touched by another mapping.
+        salesforce_instance = mapping.salesforce_record_type.find(
+          database_record.salesforce_id,
+        )
+        salesforce_instance.update! "Name" => "A Stale Synchronized Name"
+        runner.cache_timestamp salesforce_instance
+
+        # 2. The second loop runs.
+        # We sleep here to ensure we pick up our manual changes.
+        sleep 1 if VCR.current_cassette.recording?
+        worker.send :reset!
+        worker.send :collect, mapping
+        worker.send :synchronize, mapping
+      end
+    end
+
+    it "does not change the user-entered name on the database record" do
+      expect(database_record.reload.name).to_equal new_name
+    end
+
+    it "overrides the stale-but-more-recent name on the Salesforce" do
+      salesforce_instance = mapping.salesforce_record_type.find(
+        database_record.salesforce_id,
+      )
+
+      expect(salesforce_instance.record.Name).to_equal new_name
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: restforce-db
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 2.6.0
 platform: ruby
 authors:
 - Andrew Horner
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-06-15 00:00:00.000000000 Z
+date: 2015-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -298,6 +298,8 @@ files:
 - test/cassettes/Restforce_DB_Instances_Salesforce/_update_/updates_the_record_in_Salesforce_with_the_passed_attributes.yml
 - test/cassettes/Restforce_DB_Instances_Salesforce/_updated_internally_/when_another_user_made_the_last_change/returns_false.yml
 - test/cassettes/Restforce_DB_Instances_Salesforce/_updated_internally_/when_our_client_made_the_last_change/returns_true.yml
+- test/cassettes/Restforce_DB_Model/given_a_database_model_which_includes_the_module/_force_sync_/given_a_previously-synchronized_record_for_a_mapped_model/force-updates_both_synchronized_records.yml
+- test/cassettes/Restforce_DB_Model/given_a_database_model_which_includes_the_module/_force_sync_/given_an_unsynchronized_record_for_a_mapped_model/creates_a_matching_record_in_Salesforce.yml
 - test/cassettes/Restforce_DB_RecordTypes_Salesforce/_all/returns_a_list_of_the_existing_records_in_Salesforce.yml
 - test/cassettes/Restforce_DB_RecordTypes_Salesforce/_create_/creates_a_record_in_Salesforce_from_the_passed_database_record_s_attributes.yml
 - test/cassettes/Restforce_DB_RecordTypes_Salesforce/_create_/updates_the_database_record_with_the_Salesforce_record_s_ID.yml
@@ -317,6 +319,8 @@ files:
 - test/cassettes/Restforce_DB_Synchronizer/_run/given_a_Salesforce_record_with_an_associated_database_record/when_the_changes_are_current/updates_the_database_record.yml
 - test/cassettes/Restforce_DB_Synchronizer/_run/given_a_Salesforce_record_with_an_associated_database_record/when_the_changes_are_current/updates_the_salesforce_record.yml
 - test/cassettes/Restforce_DB_Synchronizer/_run/given_a_Salesforce_record_with_no_associated_database_record/does_nothing_for_this_specific_mapping.yml
+- test/cassettes/Restforce_DB_Worker/a_race_condition_during_synchronization/does_not_change_the_user-entered_name_on_the_database_record.yml
+- test/cassettes/Restforce_DB_Worker/a_race_condition_during_synchronization/overrides_the_stale-but-more-recent_name_on_the_Salesforce.yml
 - test/lib/restforce/db/accumulator_test.rb
 - test/lib/restforce/db/adapter_test.rb
 - test/lib/restforce/db/association_cache_test.rb
@@ -347,6 +351,7 @@ files:
 - test/lib/restforce/db/synchronizer_test.rb
 - test/lib/restforce/db/timestamp_cache_test.rb
 - test/lib/restforce/db/tracker_test.rb
+- test/lib/restforce/db/worker_test.rb
 - test/lib/restforce/db_test.rb
 - test/support/active_record.rb
 - test/support/database_cleaner.rb