restforce-db 0.2.3 → 0.3.0

data/test/lib/restforce/db/record_types/active_record_test.rb

@@ -3,9 +3,9 @@ require_relative "../../../../test_helper"
 describe Restforce::DB::RecordTypes::ActiveRecord do
 
   configure!
+  mappings!
 
-  let(:mapping) { Restforce::DB::Mapping.new }
-  let(:record_type) { Restforce::DB::RecordTypes::ActiveRecord.new(CustomObject, mapping) }
+  let(:record_type) { mapping.database_record_type }
   let(:salesforce_id) { "a001a000001E1vREAL" }
 
   describe "#sync!" do
@@ -19,10 +19,6 @@ describe Restforce::DB::RecordTypes::ActiveRecord do
     end
     let(:instance) { record_type.sync!(sync_from).record }
 
-    before do
-      mapping.add_mappings(name: "Name", example: "Example_Field__c")
-    end
-
     describe "without an existing database record" do
 
       it "creates a new database record from the passed Salesforce record" do
@@ -35,7 +31,7 @@ describe Restforce::DB::RecordTypes::ActiveRecord do
 
     describe "with an existing database record" do
       let!(:sync_to) do
-        CustomObject.create!(
+        database_model.create!(
           name:            "Existing name",
           example:         "Existing sample text",
           salesforce_id:   salesforce_id,
@@ -53,32 +49,64 @@ describe Restforce::DB::RecordTypes::ActiveRecord do
   end
 
   describe "#create!" do
+    let(:attributes) do
+      {
+        name:    "Some name",
+        example: "Some text",
+      }
+    end
+    let(:record) { nil }
     let(:create_from) do
-      Struct.new(:id, :last_update, :attributes).new(
+      Struct.new(:id, :last_update, :attributes, :record).new(
         salesforce_id,
         Time.now,
-        name:    "Some name",
-        example: "Some text",
+        attributes,
+        record,
       )
     end
     let(:instance) { record_type.create!(create_from).record }
 
-    before do
-      mapping.add_mappings(name: "Name", example: "Example_Field__c")
-    end
-
     it "creates a record in the database from the passed Salesforce record's attributes" do
       expect(instance.salesforce_id).to_equal salesforce_id
-      expect(instance.name).to_equal create_from.attributes[:name]
-      expect(instance.example).to_equal create_from.attributes[:example]
+      expect(instance.name).to_equal attributes[:name]
+      expect(instance.example).to_equal attributes[:example]
       expect(instance.synchronized_at).to_not_be_nil
     end
+
+    describe "given a mapped association" do
+      let(:record) { Struct.new(:Friend__c).new(association_id) }
+      let(:association_id) { "a001a000001EFRIEND" }
+      let(:associations) { { user: "Friend__c" } }
+
+      before do
+        mapping = Restforce::DB::Mapping.new(User, "Contact", fields: { email: "Email" })
+        salesforce_record_type = mapping.salesforce_record_type
+
+        # Stub out the `#find` method on the record type
+        def salesforce_record_type.find(id)
+          Struct.new(:id, :last_update, :attributes).new(
+            id,
+            Time.now,
+            email: "somebody@example.com",
+          )
+        end
+      end
+
+      it "creates the associated record from the related Salesforce record's attributes" do
+        user = instance.reload.user
+
+        expect(user).to_not_be_nil
+        expect(user.email).to_equal("somebody@example.com")
+        expect(user.salesforce_id).to_equal(association_id)
+        expect(user.synchronized_at).to_not_be_nil
+      end
+    end
   end
 
   describe "#find" do
 
     it "finds existing records in the database by their salesforce id" do
-      CustomObject.create!(salesforce_id: salesforce_id)
+      database_model.create!(salesforce_id: salesforce_id)
       expect(record_type.find(salesforce_id)).to_be_instance_of Restforce::DB::Instances::ActiveRecord
     end
 

data/test/lib/restforce/db/record_types/salesforce_test.rb

@@ -3,23 +3,22 @@ require_relative "../../../../test_helper"
 describe Restforce::DB::RecordTypes::Salesforce do
 
   configure!
+  mappings!
 
-  let(:mapping) { Restforce::DB::Mapping.new }
-  let(:record_type) { Restforce::DB::RecordTypes::Salesforce.new("CustomObject__c", mapping) }
+  let(:record_type) { mapping.salesforce_record_type }
 
   describe "#create!", :vcr do
     let(:database_record) do
-      CustomObject.create!(
+      database_model.create!(
         name: "Something",
         example: "Something else",
       )
     end
-    let(:sync_from) { Restforce::DB::Instances::ActiveRecord.new(database_record, mapping) }
+    let(:sync_from) { Restforce::DB::Instances::ActiveRecord.new(database_model, database_record, mapping) }
     let(:instance) { record_type.create!(sync_from).record }
 
     before do
-      mapping.add_mappings name: "Name", example: "Example_Field__c"
-      Salesforce.records << ["CustomObject__c", instance.Id]
+      Salesforce.records << [salesforce_model, instance.Id]
     end
 
     it "creates a record in Salesforce from the passed database record's attributes" do
@@ -33,7 +32,7 @@ describe Restforce::DB::RecordTypes::Salesforce do
   end
 
   describe "#find", :vcr do
-    let(:id) { Salesforce.create!("CustomObject__c") }
+    let(:id) { Salesforce.create!(salesforce_model) }
 
     it "finds existing records in Salesforce" do
       expect(record_type.find(id)).to_be_instance_of Restforce::DB::Instances::Salesforce

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

@@ -3,11 +3,9 @@ require_relative "../../../test_helper"
 describe Restforce::DB::Synchronizer do
 
   configure!
+  mappings!
 
-  let(:mapping) { Restforce::DB::Mapping.new(name: "Name", example: "Example_Field__c") }
-  let(:database_type) { Restforce::DB::RecordTypes::ActiveRecord.new(CustomObject, mapping) }
-  let(:salesforce_type) { Restforce::DB::RecordTypes::Salesforce.new("CustomObject__c", mapping) }
-  let(:synchronizer) { Restforce::DB::Synchronizer.new(database_type, salesforce_type) }
+  let(:synchronizer) { mapping.synchronizer }
 
   describe "#initialize" do
     before { Restforce::DB.last_run = Time.now }
@@ -27,39 +25,55 @@ describe Restforce::DB::Synchronizer do
     end
     let(:salesforce_id) do
       Salesforce.create!(
-        "CustomObject__c",
-        mapping.convert(:salesforce, attributes),
+        salesforce_model,
+        mapping.convert(salesforce_model, attributes),
       )
     end
 
     describe "given an existing Salesforce record" do
       before do
         salesforce_id
-        synchronizer.run
       end
 
-      it "populates the database with the new record" do
-        record = CustomObject.last
+      describe "for a root mapping" do
+        before do
+          synchronizer.run
+        end
+
+        it "creates a matching database record" do
+          record = database_model.last
 
-        expect(record.name).to_equal attributes[:name]
-        expect(record.example).to_equal attributes[:example]
-        expect(record.salesforce_id).to_equal salesforce_id
+          expect(record.name).to_equal attributes[:name]
+          expect(record.example).to_equal attributes[:example]
+          expect(record.salesforce_id).to_equal salesforce_id
+        end
+      end
+
+      describe "for a non-root mapping" do
+        before do
+          mapping.root = false
+          synchronizer.run
+        end
+
+        it "does not create a database record" do
+          expect(database_model.last).to_be_nil
+        end
       end
     end
 
     describe "given an existing database record" do
-      let(:database_record) { CustomObject.create!(attributes) }
+      let(:database_record) { database_model.create!(attributes) }
       let(:salesforce_id) { database_record.reload.salesforce_id }
 
       before do
         database_record
         synchronizer.run
 
-        Salesforce.records << ["CustomObject__c", salesforce_id]
+        Salesforce.records << [salesforce_model, salesforce_id]
       end
 
       it "populates Salesforce with the new record" do
-        record = salesforce_type.find(salesforce_id).record
+        record = mapping.salesforce_record_type.find(salesforce_id).record
 
         expect(record.Name).to_equal attributes[:name]
         expect(record.Example_Field__c).to_equal attributes[:example]
@@ -75,14 +89,14 @@ describe Restforce::DB::Synchronizer do
         }
       end
       let(:database_record) do
-        CustomObject.create!(database_attributes.merge(salesforce_id: salesforce_id))
+        database_model.create!(database_attributes.merge(salesforce_id: salesforce_id))
       end
 
       describe "when synchronization is stale" do
         before do
           # Set the synchronization timestamp to 5 seconds before the Salesforce
           # modification timestamp.
-          updated = salesforce_type.find(salesforce_id).last_update
+          updated = mapping.salesforce_record_type.find(salesforce_id).last_update
           database_record.update!(synchronized_at: updated - 5)
 
           synchronizer.run

data/test/support/active_record.rb

@@ -7,15 +7,34 @@ ActiveRecord::Base.establish_connection(
 )
 
 ActiveRecord::Schema.define do
+
   create_table :custom_objects do |table|
     table.column :name,            :string
     table.column :example,         :string
+    table.column :user_id,         :integer
     table.column :salesforce_id,   :string
     table.column :synchronized_at, :datetime
     table.timestamps null: false
   end
 
   add_index :custom_objects, :salesforce_id
+
+  create_table :users do |table|
+    table.column :email,           :string
+    table.column :salesforce_id,   :string
+    table.column :synchronized_at, :datetime
+    table.timestamps null: false
+  end
+
+  add_index :users, :salesforce_id
+
+end
+
+# :nodoc:
+class CustomObject < ActiveRecord::Base
+
+  belongs_to :user
+
 end
 
-class CustomObject < ActiveRecord::Base; end
+class User < ActiveRecord::Base; end

data/test/support/utilities.rb

@@ -0,0 +1,29 @@
+# :nodoc:
+def configure!
+  before do
+    Salesforce.configure!
+  end
+
+  after do
+    Restforce::DB::Mapping.collection = {}
+    DatabaseCleaner.clean
+    Salesforce.clean!
+  end
+end
+
+# :nodoc:
+def mappings!
+  let(:database_model) { CustomObject }
+  let(:salesforce_model) { "CustomObject__c" }
+  let(:fields) { { name: "Name", example: "Example_Field__c" } }
+  let(:associations) { {} }
+  let!(:mapping) do
+    Restforce::DB::Mapping.new(
+      database_model,
+      salesforce_model,
+      root: true,
+      fields: fields,
+      associations: associations,
+    )
+  end
+end

data/test/test_helper.rb

@@ -11,15 +11,3 @@ secrets_file = File.expand_path("../config/secrets.yml", __FILE__)
 Secrets = YAML.load_file(secrets_file)
 
 Dir[File.join(File.dirname(__FILE__), "support/**/*.rb")].each { |f| require f }
-
-# :nodoc:
-def configure!
-  before do
-    Salesforce.configure!
-  end
-
-  after do
-    DatabaseCleaner.clean
-    Salesforce.clean!
-  end
-end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: restforce-db
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Andrew Horner
@@ -227,7 +227,6 @@ files:
 - lib/restforce/db/instances/salesforce.rb
 - lib/restforce/db/mapping.rb
 - lib/restforce/db/model.rb
-- lib/restforce/db/record_type.rb
 - lib/restforce/db/record_types/active_record.rb
 - lib/restforce/db/record_types/base.rb
 - lib/restforce/db/record_types/salesforce.rb
@@ -247,14 +246,14 @@ files:
 - test/cassettes/Restforce_DB_RecordTypes_Salesforce/_find/returns_nil_when_no_matching_record_exists.yml
 - test/cassettes/Restforce_DB_Synchronizer/_run/given_a_Salesforce_record_with_an_associated_database_record/when_synchronization_is_stale/updates_the_database_record.yml
 - test/cassettes/Restforce_DB_Synchronizer/_run/given_a_Salesforce_record_with_an_associated_database_record/when_synchronization_is_up-to-date/does_not_update_the_database_record.yml
-- test/cassettes/Restforce_DB_Synchronizer/_run/given_an_existing_Salesforce_record/populates_the_database_with_the_new_record.yml
+- test/cassettes/Restforce_DB_Synchronizer/_run/given_an_existing_Salesforce_record/for_a_non-root_mapping/does_not_create_a_database_record.yml
+- test/cassettes/Restforce_DB_Synchronizer/_run/given_an_existing_Salesforce_record/for_a_root_mapping/creates_a_matching_database_record.yml
 - test/cassettes/Restforce_DB_Synchronizer/_run/given_an_existing_database_record/populates_Salesforce_with_the_new_record.yml
 - test/lib/restforce/db/configuration_test.rb
 - test/lib/restforce/db/instances/active_record_test.rb
 - test/lib/restforce/db/instances/salesforce_test.rb
 - test/lib/restforce/db/mapping_test.rb
 - test/lib/restforce/db/model_test.rb
-- test/lib/restforce/db/record_type_test.rb
 - test/lib/restforce/db/record_types/active_record_test.rb
 - test/lib/restforce/db/record_types/salesforce_test.rb
 - test/lib/restforce/db/synchronizer_test.rb
@@ -263,6 +262,7 @@ files:
 - test/support/active_record.rb
 - test/support/database_cleaner.rb
 - test/support/salesforce.rb
+- test/support/utilities.rb
 - test/support/vcr.rb
 - test/test_helper.rb
 homepage: https://www.github.com/tablexi/restforce-db

data/lib/restforce/db/record_type.rb

@@ -1,77 +0,0 @@
-module Restforce
-
-  module DB
-
-    # Restforce::DB::RecordType is an abstraction for a two-way binding between
-    # an ActiveRecord class and a Salesforce object type. It provides an
-    # interface for mapping database columns to Salesforce fields.
-    class RecordType
-
-      class << self
-
-        include Enumerable
-        attr_accessor :collection
-
-        # Public: Get the Restforce::DB::RecordType entry for the specified
-        # database model.
-        #
-        # database_model - A Class compatible with ActiveRecord::Base.
-        #
-        # Returns a Restforce::DB::RecordType.
-        def [](database_model)
-          collection[database_model]
-        end
-
-        # Public: Iterate through all registered Restforce::DB::RecordTypes.
-        #
-        # Yields one RecordType for each database-to-Salesforce mapping.
-        # Returns nothing.
-        def each
-          collection.each do |database_model, record_type|
-            yield database_model.name, record_type
-          end
-        end
-
-      end
-
-      self.collection ||= {}
-      attr_reader :mapping, :synchronizer
-
-      # Public: Initialize and register a Restforce::DB::RecordType.
-      #
-      # database_model   - A Class compatible with ActiveRecord::Base.
-      # salesforce_model - A String name of an object type in Salesforce.
-      # mappings         - A Hash of mappings between database columns and
-      #                    fields in Salesforce.
-      def initialize(database_model, salesforce_model, **mappings)
-        @mapping = Mapping.new(mappings)
-        @database_record_type = RecordTypes::ActiveRecord.new(database_model, @mapping)
-        @salesforce_record_type = RecordTypes::Salesforce.new(salesforce_model, @mapping)
-        @synchronizer = Synchronizer.new(@database_record_type, @salesforce_record_type)
-
-        self.class.collection[database_model] = self
-      end
-
-      # Public: Append the passed mappings to this model.
-      #
-      # mappings - A Hash of database column names mapped to Salesforce fields.
-      #
-      # Returns nothing.
-      def add_mappings(mappings)
-        @mapping.add_mappings mappings
-      end
-
-      # Public: Synchronize the records between the database and Salesforce.
-      #
-      # options - A Hash of options to pass to the synchronizer.
-      #
-      # Returns nothing.
-      def synchronize(options = {})
-        @synchronizer.run(options)
-      end
-
-    end
-
-  end
-
-end

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

@@ -1,26 +0,0 @@
-require_relative "../../../test_helper"
-
-describe Restforce::DB::RecordType do
-
-  configure!
-
-  let(:database_model) { CustomObject }
-  let(:salesforce_model) { "CustomObject__c" }
-  let!(:record_type) { Restforce::DB::RecordType.new(database_model, salesforce_model) }
-
-  describe "#initialize" do
-
-    it "registers the record type in the master collection" do
-      expect(Restforce::DB::RecordType[database_model]).to_equal(record_type)
-    end
-  end
-
-  describe ".each" do
-
-    # Restforce::DB::RecordType actually implements Enumerable, so we're just
-    # going with a trivially testable portion of the Enumerable API.
-    it "yields the registered record types" do
-      expect(Restforce::DB::RecordType.first).to_equal [database_model.name, record_type]
-    end
-  end
-end