restforce-db 1.0.4 → 1.1.0

data/test/lib/restforce/db/associations/has_one_test.rb

@@ -0,0 +1,80 @@
+require_relative "../../../../test_helper"
+
+describe Restforce::DB::Associations::HasOne do
+
+  configure!
+  mappings!
+
+  let(:association) { Restforce::DB::Associations::HasOne.new(:custom_object, through: "Friend__c") }
+
+  it "sets the lookup field" do
+    expect(association.lookup).to_equal "Friend__c"
+  end
+
+  describe "#fields" do
+
+    it "returns nothing (since the lookup field is external)" do
+      expect(association.fields).to_equal []
+    end
+  end
+
+  describe "with an inverse mapping", :vcr do
+    let(:inverse_mapping) do
+      Restforce::DB::Mapping.new(User, "Contact").tap do |m|
+        m.fields = { email: "Email" }
+        m.associations << association
+      end
+    end
+    let(:user_salesforce_id) do
+      Salesforce.create!(
+        inverse_mapping.salesforce_model,
+        "Email" => "somebody@example.com",
+        "LastName" => "Somebody",
+      )
+    end
+    let(:object_salesforce_id) do
+      Salesforce.create!(mapping.salesforce_model, "Friend__c" => user_salesforce_id)
+    end
+
+    before do
+      Restforce::DB::Registry << mapping
+      Restforce::DB::Registry << inverse_mapping
+      mapping.associations << Restforce::DB::Associations::BelongsTo.new(:user, through: "Friend__c")
+
+      object_salesforce_id
+    end
+
+    describe "#synced_for?" do
+      let(:salesforce_instance) { inverse_mapping.salesforce_record_type.find(user_salesforce_id) }
+
+      describe "when no matching associated record has been synchronized" do
+
+        it "returns false" do
+          expect(association).to_not_be :synced_for?, salesforce_instance
+        end
+      end
+
+      describe "when a matching associated record has been synchronized" do
+        before do
+          mapping.database_model.create!(salesforce_id: object_salesforce_id)
+        end
+
+        it "returns true" do
+          expect(association).to_be :synced_for?, salesforce_instance
+        end
+      end
+    end
+
+    describe "#build" do
+      let(:database_record) { User.new }
+      let(:salesforce_record) { inverse_mapping.salesforce_record_type.find(user_salesforce_id).record }
+      let(:associated) { association.build(database_record, salesforce_record) }
+
+      it "returns an associated record, populated with the Salesforce attributes" do
+        expect(associated.user).to_equal database_record
+        expect(associated.salesforce_id).to_equal object_salesforce_id
+      end
+    end
+  end
+
+end

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

@@ -52,7 +52,10 @@ describe Restforce::DB::DSL do
     end
 
     it "adds an association to the created mapping" do
-      expect(mapping.associations).to_equal some_association: "Some_Field__c"
+      association = mapping.associations.first
+      expect(association).to_be_instance_of Restforce::DB::Associations::BelongsTo
+      expect(association.name).to_equal :some_association
+      expect(association.lookup).to_equal "Some_Field__c"
     end
   end
 
@@ -61,8 +64,24 @@ describe Restforce::DB::DSL do
       dsl.has_one :other_association, through: "Other_Field__c"
     end
 
-    it "sets the `through` attribute for the created mapping" do
-      expect(mapping.through).to_equal "Other_Field__c"
+    it "adds an association to the created mapping" do
+      association = mapping.associations.first
+      expect(association).to_be_instance_of Restforce::DB::Associations::HasOne
+      expect(association.name).to_equal :other_association
+      expect(association.lookup).to_equal "Other_Field__c"
+    end
+  end
+
+  describe "#has_many" do
+    before do
+      dsl.has_many :multiple_associations, through: "External_Field__c"
+    end
+
+    it "adds an association to the created mapping" do
+      association = mapping.associations.first
+      expect(association).to_be_instance_of Restforce::DB::Associations::HasMany
+      expect(association.name).to_equal :multiple_associations
+      expect(association.lookup).to_equal "External_Field__c"
     end
   end
 

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

@@ -6,19 +6,15 @@ describe Restforce::DB::Mapping do
 
   let(:database_model) { CustomObject }
   let(:salesforce_model) { "CustomObject__c" }
-  let(:associations) { {} }
   let(:fields) do
     {
       column_one: "SF_Field_One__c",
       column_two: "SF_Field_Two__c",
     }
   end
-  let(:through) { nil }
-  let!(:mapping) do
+  let(:mapping) do
     Restforce::DB::Mapping.new(database_model, salesforce_model).tap do |m|
-      m.fields       = fields
-      m.associations = associations
-      m.through      = through
+      m.fields = fields
     end
   end
 
@@ -39,10 +35,16 @@ describe Restforce::DB::Mapping do
     end
 
     describe "given a set of associations" do
-      let(:associations) { { user: "Owner" } }
+      let(:association) do
+        Restforce::DB::Associations::BelongsTo.new(:user, through: "Owner")
+      end
+
+      before do
+        mapping.associations << association
+      end
 
       it "lists the field and association lookups" do
-        expect(mapping.salesforce_fields).to_equal(fields.values + associations.values)
+        expect(mapping.salesforce_fields).to_equal(fields.values + association.fields)
       end
     end
   end

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

@@ -40,16 +40,23 @@ describe Restforce::DB::RecordTypes::ActiveRecord do
     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").tap do |m|
-          m.through = "Friend__c"
+        mapping.associations << Restforce::DB::Associations::BelongsTo.new(
+          :user,
+          through: "Friend__c",
+        )
+
+        associated_mapping = Restforce::DB::Mapping.new(User, "Contact").tap do |m|
           m.fields  = { email: "Email" }
+          m.associations << Restforce::DB::Associations::HasOne.new(
+            :custom_object,
+            through: "Friend__c",
+          )
         end
-        Restforce::DB::Registry << mapping
+        Restforce::DB::Registry << associated_mapping
 
-        salesforce_record_type = mapping.salesforce_record_type
+        salesforce_record_type = associated_mapping.salesforce_record_type
 
         # Stub out the `#find` method on the record type
         def salesforce_record_type.find(id)

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

@@ -1,12 +1,10 @@
 require_relative "../../../test_helper"
 
 describe Restforce::DB::Runner do
-  before { Restforce::DB.last_run = Time.now }
-  after { Restforce::DB.last_run = nil }
-
   let(:runner) { Restforce::DB::Runner.new }
 
   describe "#initialize" do
+    before { Restforce::DB.last_run = Time.now }
 
     it "prefills the Collector's last_run timestamp with the global configuration" do
       expect(runner.last_run).to_equal Restforce::DB.last_run
@@ -14,6 +12,7 @@ describe Restforce::DB::Runner do
   end
 
   describe "#tick!" do
+    before { Restforce::DB.last_run = Time.now }
 
     it "updates the run timestamps" do
       prior_run = runner.last_run

data/test/lib/restforce/db/strategies/always_test.rb

@@ -18,7 +18,7 @@ describe Restforce::DB::Strategies::Always do
       let(:record) { mapping.salesforce_record_type.find(salesforce_id) }
 
       it "wants to build a new matching record" do
-        expect(strategy.build?(record)).to_equal true
+        expect(strategy).to_be :build?, record
       end
 
       describe "with a corresponding database record" do
@@ -30,7 +30,7 @@ describe Restforce::DB::Strategies::Always do
         end
 
         it "does not want to build a new record" do
-          expect(strategy.build?(record)).to_equal false
+          expect(strategy).to_not_be :build?, record
         end
       end
     end

data/test/lib/restforce/db/strategies/associated_test.rb

@@ -0,0 +1,78 @@
+require_relative "../../../../test_helper"
+
+describe Restforce::DB::Strategies::Associated do
+
+  configure!
+  mappings!
+
+  let(:strategy) { Restforce::DB::Strategies::Associated.new(with: :custom_object) }
+
+  it "is not a passive strategy" do
+    expect(strategy).to_not_be :passive?
+  end
+
+  describe "#build?", :vcr do
+
+    describe "given an inverse mapping" do
+      let(:inverse_mapping) do
+        Restforce::DB::Mapping.new(Detail, "CustomObjectDetail__c").tap do |m|
+          m.fields = { name: "Name" }
+          m.associations << Restforce::DB::Associations::BelongsTo.new(
+            :custom_object,
+            through: "CustomObject__c",
+          )
+        end
+      end
+      let(:object_salesforce_id) { Salesforce.create!(mapping.salesforce_model) }
+      let(:detail_salesforce_id) do
+        Salesforce.create!(
+          inverse_mapping.salesforce_model,
+          "CustomObject__c" => object_salesforce_id,
+        )
+      end
+      let(:record) { inverse_mapping.salesforce_record_type.find(detail_salesforce_id) }
+
+      before do
+        Restforce::DB::Registry << mapping
+        Restforce::DB::Registry << inverse_mapping
+        mapping.associations << Restforce::DB::Associations::HasMany.new(
+          :details,
+          through: "CustomObject__c",
+        )
+      end
+
+      describe "with no synchronized association record" do
+
+        it "does not want to build a new record" do
+          expect(strategy).to_not_be :build?, record
+        end
+      end
+
+      describe "with an existing database record" do
+        before do
+          Detail.create!(
+            salesforce_id: detail_salesforce_id,
+            synchronized_at: Time.now,
+          )
+        end
+
+        it "does not want to build a new record" do
+          expect(strategy).to_not_be :build?, record
+        end
+      end
+
+      describe "with a synchronized association record" do
+        before do
+          CustomObject.create!(
+            salesforce_id: object_salesforce_id,
+            synchronized_at: Time.now,
+          )
+        end
+
+        it "wants to build a new record" do
+          expect(strategy).to_be :build?, record
+        end
+      end
+    end
+  end
+end

data/test/lib/restforce/db/strategies/passive_test.rb

@@ -11,7 +11,7 @@ describe Restforce::DB::Strategies::Passive do
 
     it "returns false for any record" do
       record = Object.new
-      expect(strategy.build?(record)).to_equal false
+      expect(strategy).to_not_be :build?, record
     end
   end
 end

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

@@ -5,8 +5,6 @@ describe Restforce::DB::Tracker do
   let(:tracker) { Restforce::DB::Tracker.new(file.path) }
   let(:runtime) { Time.now }
 
-  after { Restforce::DB.last_run = nil }
-
   describe "#initialize" do
 
     describe "when no timestamp has been recorded" do

data/test/support/active_record.rb

@@ -19,6 +19,16 @@ ActiveRecord::Schema.define do
 
   add_index :custom_objects, :salesforce_id
 
+  create_table :details do |table|
+    table.column :name,             :string
+    table.column :custom_object_id, :integer
+    table.column :salesforce_id,    :string
+    table.column :synchronized_at,  :datetime
+    table.timestamps null: false
+  end
+
+  add_index :details, :salesforce_id
+
   create_table :users do |table|
     table.column :email,           :string
     table.column :salesforce_id,   :string
@@ -33,8 +43,21 @@ end
 # :nodoc:
 class CustomObject < ActiveRecord::Base
 
-  belongs_to :user
+  belongs_to :user, inverse_of: :custom_object, autosave: true
+  has_many :details, inverse_of: :custom_object
 
 end
 
-class User < ActiveRecord::Base; end
+# :nodoc:
+class Detail < ActiveRecord::Base
+
+  belongs_to :custom_object, inverse_of: :details
+
+end
+
+# :nodoc:
+class User < ActiveRecord::Base
+
+  has_one :custom_object, inverse_of: :user
+
+end

data/test/support/salesforce.rb

@@ -24,7 +24,7 @@ class Salesforce
   # Returns a Salesforce record ID.
   def self.create!(salesforce_model, attributes = nil)
     attributes ||= { "Name" => "Sample object" }
-    salesforce_id = Restforce::DB.client.create(salesforce_model, attributes)
+    salesforce_id = Restforce::DB.client.create!(salesforce_model, attributes)
     Salesforce.records << [salesforce_model, salesforce_id]
 
     salesforce_id

data/test/support/utilities.rb

@@ -6,6 +6,8 @@ def configure!
 
   after do
     Restforce::DB::Registry.clean!
+    Restforce::DB.last_run = nil
+
     DatabaseCleaner.clean
     Salesforce.clean!
   end
@@ -16,15 +18,11 @@ def mappings!
   let(:database_model) { CustomObject }
   let(:salesforce_model) { "CustomObject__c" }
   let(:fields) { { name: "Name", example: "Example_Field__c" } }
-  let(:associations) { {} }
   let(:conditions) { [] }
-  let(:through) { nil }
-  let!(:mapping) do
+  let(:mapping) do
     Restforce::DB::Mapping.new(database_model, salesforce_model).tap do |m|
-      m.through      = through
-      m.conditions   = conditions
-      m.fields       = fields
-      m.associations = associations
+      m.conditions = conditions
+      m.fields     = fields
     end
   end
 end

data/test/test_helper.rb

@@ -1,6 +1,5 @@
 require "cgi"
 require "minitest/autorun"
-require "minitest/bang"
 require "minitest/spec/expect"
 require "yaml"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: restforce-db
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.1.0
 platform: ruby
 authors:
 - Andrew Horner
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-04-10 00:00:00.000000000 Z
+date: 2015-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -94,20 +94,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: minitest-bang
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest-spec-expect
   requirement: !ruby/object:Gem::Requirement
@@ -222,7 +208,11 @@ files:
 - lib/generators/templates/script
 - lib/restforce/db.rb
 - lib/restforce/db/accumulator.rb
-- lib/restforce/db/associations/active_record.rb
+- lib/restforce/db/associations/base.rb
+- lib/restforce/db/associations/belongs_to.rb
+- lib/restforce/db/associations/foreign_key.rb
+- lib/restforce/db/associations/has_many.rb
+- lib/restforce/db/associations/has_one.rb
 - lib/restforce/db/attribute_map.rb
 - lib/restforce/db/collector.rb
 - lib/restforce/db/command.rb
@@ -240,6 +230,7 @@ files:
 - lib/restforce/db/registry.rb
 - lib/restforce/db/runner.rb
 - lib/restforce/db/strategies/always.rb
+- lib/restforce/db/strategies/associated.rb
 - lib/restforce/db/strategies/passive.rb
 - lib/restforce/db/strategy.rb
 - lib/restforce/db/synchronizer.rb
@@ -249,6 +240,15 @@ files:
 - lib/restforce/extensions.rb
 - restforce-db.gemspec
 - test/cassettes/Restforce_DB/accessing_Salesforce/uses_the_configured_credentials.yml
+- test/cassettes/Restforce_DB_Associations_BelongsTo/with_an_inverse_mapping/_build/returns_an_associated_record_populated_with_the_Salesforce_attributes.yml
+- test/cassettes/Restforce_DB_Associations_BelongsTo/with_an_inverse_mapping/_synced_for_/when_a_matching_associated_record_has_been_synchronized/returns_true.yml
+- test/cassettes/Restforce_DB_Associations_BelongsTo/with_an_inverse_mapping/_synced_for_/when_no_matching_associated_record_has_been_synchronized/returns_false.yml
+- test/cassettes/Restforce_DB_Associations_HasMany/with_an_inverse_mapping/_build/builds_a_number_of_associated_records_from_the_data_in_Salesforce.yml
+- test/cassettes/Restforce_DB_Associations_HasMany/with_an_inverse_mapping/_synced_for_/when_a_matching_associated_record_has_been_synchronized/returns_true.yml
+- test/cassettes/Restforce_DB_Associations_HasMany/with_an_inverse_mapping/_synced_for_/when_no_matching_associated_record_has_been_synchronized/returns_false.yml
+- test/cassettes/Restforce_DB_Associations_HasOne/with_an_inverse_mapping/_build/returns_an_associated_record_populated_with_the_Salesforce_attributes.yml
+- test/cassettes/Restforce_DB_Associations_HasOne/with_an_inverse_mapping/_synced_for_/when_a_matching_associated_record_has_been_synchronized/returns_true.yml
+- test/cassettes/Restforce_DB_Associations_HasOne/with_an_inverse_mapping/_synced_for_/when_no_matching_associated_record_has_been_synchronized/returns_false.yml
 - test/cassettes/Restforce_DB_Collector/_run/given_a_Salesforce_record_with_an_associated_database_record/returns_the_attributes_from_both_records.yml
 - test/cassettes/Restforce_DB_Collector/_run/given_an_existing_Salesforce_record/returns_the_attributes_from_the_Salesforce_record.yml
 - test/cassettes/Restforce_DB_Collector/_run/given_an_existing_database_record/returns_the_attributes_from_the_database_record.yml
@@ -269,11 +269,16 @@ files:
 - test/cassettes/Restforce_DB_RecordTypes_Salesforce/_find/returns_nil_when_no_matching_record_exists.yml
 - test/cassettes/Restforce_DB_Strategies_Always/_build_/given_a_Salesforce_record/wants_to_build_a_new_matching_record.yml
 - test/cassettes/Restforce_DB_Strategies_Always/_build_/given_a_Salesforce_record/with_a_corresponding_database_record/does_not_want_to_build_a_new_record.yml
+- test/cassettes/Restforce_DB_Strategies_Associated/_build_/given_an_inverse_mapping/with_a_synchronized_association_record/wants_to_build_a_new_record.yml
+- test/cassettes/Restforce_DB_Strategies_Associated/_build_/given_an_inverse_mapping/with_an_existing_database_record/does_not_want_to_build_a_new_record.yml
+- test/cassettes/Restforce_DB_Strategies_Associated/_build_/given_an_inverse_mapping/with_no_synchronized_association_record/does_not_want_to_build_a_new_record.yml
 - test/cassettes/Restforce_DB_Synchronizer/_run/given_a_Salesforce_record_with_an_associated_database_record/updates_the_database_record.yml
 - test/cassettes/Restforce_DB_Synchronizer/_run/given_a_Salesforce_record_with_an_associated_database_record/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/lib/restforce/db/accumulator_test.rb
-- test/lib/restforce/db/associations/active_record_test.rb
+- test/lib/restforce/db/associations/belongs_to_test.rb
+- test/lib/restforce/db/associations/has_many_test.rb
+- test/lib/restforce/db/associations/has_one_test.rb
 - test/lib/restforce/db/attribute_map_test.rb
 - test/lib/restforce/db/collector_test.rb
 - test/lib/restforce/db/configuration_test.rb
@@ -288,6 +293,7 @@ files:
 - test/lib/restforce/db/registry_test.rb
 - test/lib/restforce/db/runner_test.rb
 - test/lib/restforce/db/strategies/always_test.rb
+- test/lib/restforce/db/strategies/associated_test.rb
 - test/lib/restforce/db/strategies/passive_test.rb
 - test/lib/restforce/db/strategy_test.rb
 - test/lib/restforce/db/synchronizer_test.rb

data/lib/restforce/db/associations/active_record.rb

@@ -1,68 +0,0 @@
-module Restforce
-
-  module DB
-
-    module Associations
-
-      # Restforce::DB::Associations::ActiveRecord is a utility class which
-      # encapsulates the logic for creating/populating a one-to-one association
-      #
-      class ActiveRecord
-
-        attr_reader :associated
-
-        # Public: Initialize a new Restforce::DB::Associations::ActiveRecord.
-        #
-        # record      - The base ActiveRecord::Base instance for which the
-        #               association should be built.
-        # association - The name of the association which should be built.
-        def initialize(record, association)
-          @record = record
-          @associated = record.association(association).build
-        end
-
-        # Public: Build the associated record from the attributes found on the
-        # passed Salesforce record's lookups.
-        #
-        # from_record - A Hashie::Mash representing a base Salesforce record.
-        #
-        # Returns the constructed associated record.
-        def build(from_record)
-          Registry[associated.class].each do |mapping|
-            lookup_id = from_record[mapping.through]
-            apply(mapping, lookup_id)
-          end
-
-          associated
-        end
-
-        private
-
-        # Internal: Assemble the associated record, using the data from the
-        # Salesforce record corresponding to a specific lookup ID.
-        #
-        # TODO: With some refactoring, this should be possible to handle as a
-        # recursive call to the configured Mapping's database record type. Right
-        # now, nested associations are unhandled.
-        #
-        # mapping   - A Restforce::DB::Mapping.
-        # lookup_id - A Salesforce ID corresponding to the record type in the
-        #             passed Mapping.
-        #
-        # Returns nothing.
-        def apply(mapping, lookup_id)
-          return if lookup_id.nil?
-
-          salesforce_instance = mapping.salesforce_record_type.find(lookup_id)
-          attributes = mapping.convert(associated.class, salesforce_instance.attributes)
-
-          associated.assign_attributes(attributes.merge(mapping.lookup_column => lookup_id))
-        end
-
-      end
-
-    end
-
-  end
-
-end

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

@@ -1,43 +0,0 @@
-require_relative "../../../../test_helper"
-
-describe Restforce::DB::Associations::ActiveRecord do
-
-  configure!
-  mappings!
-
-  let(:associations) { { user: "Friend__c" } }
-  let(:record) { CustomObject.new }
-  let(:association) { Restforce::DB::Associations::ActiveRecord.new(record, :user) }
-
-  describe "#build" do
-    let(:association_id) { "a001a000001EFRIEND" }
-    let(:salesforce_record) { Hashie::Mash.new("Friend__c" => association_id) }
-    let(:associated_record) { association.build(salesforce_record) }
-
-    before do
-      mapping = Restforce::DB::Mapping.new(User, "Contact").tap do |m|
-        m.through = "Friend__c"
-        m.fields  = { email: "Email" }
-      end
-      Restforce::DB::Registry << mapping
-
-      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
-      expect(associated_record).to_not_be_nil
-      expect(associated_record.email).to_equal("somebody@example.com")
-      expect(associated_record.salesforce_id).to_equal(association_id)
-      expect(associated_record).to_equal record.user
-    end
-  end
-end