restforce-db 0.1.4

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

@@ -0,0 +1,39 @@
+require_relative "../../../../test_helper"
+
+describe Restforce::DB::Instances::ActiveRecord do
+
+  configure!
+
+  let(:record) { CustomObject.create! }
+  let(:mapping) { Restforce::DB::Mapping.new(example: "Example_Field__c") }
+  let(:instance) { Restforce::DB::Instances::ActiveRecord.new(record, mapping) }
+
+  describe "#update!" do
+    let(:text) { "Some new text" }
+
+    before do
+      instance.update!(example: text)
+    end
+
+    it "updates the local record with the passed attributes" do
+      expect(record.example).to_equal text
+    end
+
+    it "updates the record in Salesforce with the passed attributes" do
+      expect(record.reload.example).to_equal text
+    end
+  end
+
+  describe "#copy!" do
+    let(:text) { "Copied text" }
+    let(:copy_from) { Struct.new(:attributes).new(example: text) }
+
+    before do
+      instance.copy!(copy_from)
+    end
+
+    it "updates the record with the attributes from the copied object" do
+      expect(record.example).to_equal text
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require_relative "../../../../test_helper"
+
+describe Restforce::DB::Instances::Salesforce do
+
+  configure!
+
+  let(:mapping) { Restforce::DB::Mapping.new(example: "Example_Field__c") }
+  let(:record_type) { Restforce::DB::RecordTypes::Salesforce.new("CustomObject__c", mapping) }
+  let(:id) { Salesforce.create!("CustomObject__c") }
+  let(:instance) { record_type.find(id) }
+
+  describe "#update!", :vcr do
+    let(:text) { "Some new text" }
+
+    before do
+      instance.update!("Example_Field__c" => text)
+    end
+
+    it "updates the local record with the passed attributes" do
+      expect(instance.record.Example_Field__c).to_equal text
+    end
+
+    it "updates the record in Salesforce with the passed attributes" do
+      expect(record_type.find(id).record.Example_Field__c).to_equal text
+    end
+  end
+
+  describe "#copy!", :vcr do
+    let(:text) { "Copied text" }
+    let(:copy_from) { Struct.new(:attributes).new(example: text) }
+
+    before do
+      instance.copy!(copy_from)
+    end
+
+    it "updates the record with the attributes from the copied object" do
+      expect(instance.record.Example_Field__c).to_equal text
+    end
+  end
+
+  describe "#last_update" do
+    let(:timestamp) { "2015-03-18T20:28:24.000+0000" }
+    let(:record) { Struct.new(:SystemModstamp).new(timestamp) }
+    let(:instance) { Restforce::DB::Instances::Salesforce.new(record) }
+
+    it "parses a time from the record's system modification timestamp" do
+      expect(instance.last_update).to_equal(Time.new(2015, 3, 18, 20, 28, 24, 0))
+    end
+  end
+
+end

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

@@ -0,0 +1,70 @@
+require_relative "../../../test_helper"
+
+describe Restforce::DB::Mapping do
+
+  configure!
+
+  let(:mapping) { Restforce::DB::Mapping.new(mappings) }
+  let(:mappings) do
+    {
+      column_one: "SF_Field_One__c",
+      column_two: "SF_Field_Two__c",
+    }
+  end
+
+  describe "#initialize" do
+
+    it "assigns the passed mappings to the object" do
+      expect(mapping.mappings).to_equal(mappings)
+    end
+  end
+
+  describe "#add_mappings" do
+    let(:new_mappings) { { a: "few", more: "mappings" } }
+
+    before do
+      mapping.add_mappings new_mappings
+    end
+
+    it "appends the passed mappings to the object's internal collection" do
+      expect(mapping.mappings).to_equal(mappings.merge(new_mappings))
+    end
+  end
+
+  describe "#attributes" do
+
+    it "builds a normalized Hash of database attribute values" do
+      attributes = mapping.attributes(:database) do |attribute|
+        expect(mapping.database_fields.include?(attribute)).to_equal true
+        attribute
+      end
+
+      expect(attributes.keys).to_equal(mapping.database_fields)
+      expect(attributes.values).to_equal(mapping.database_fields)
+    end
+
+    it "builds a normalized Hash of Salesforce field values" do
+      attributes = mapping.attributes(:salesforce) do |attribute|
+        expect(mapping.salesforce_fields.include?(attribute)).to_equal true
+        attribute
+      end
+
+      expect(attributes.keys).to_equal(mapping.database_fields)
+      expect(attributes.values).to_equal(mapping.salesforce_fields)
+    end
+  end
+
+  describe "#convert" do
+    let(:attributes) { { column_one: "some value" } }
+
+    it "converts an attribute Hash to a Salesforce-compatible form" do
+      expect(mapping.convert(:salesforce, attributes)).to_equal(
+        mappings[attributes.keys.first] => attributes.values.first,
+      )
+    end
+
+    it "performs no special conversion for database columns" do
+      expect(mapping.convert(:database, attributes)).to_equal(attributes)
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+require_relative "../../../test_helper"
+
+describe Restforce::DB::Model do
+
+  configure!
+
+  let(:database_model) { CustomObject }
+  let(:salesforce_model) { "CustomObject__c" }
+  let(:mappings) do
+    {
+      name:    "Name",
+      example: "Example_Field__c",
+    }
+  end
+
+  before do
+    database_model.send(:include, Restforce::DB::Model)
+  end
+
+  describe ".map_to" do
+    before do
+      database_model.map_to(salesforce_model, mappings)
+    end
+
+    it "creates a mapping in Restforce::DB::RecordType" do
+      expect(Restforce::DB::RecordType[database_model])
+        .to_be_instance_of(Restforce::DB::RecordType)
+    end
+
+    it "applies the passed attribute mappings to the registered RecordType" do
+      expect(Restforce::DB::RecordType[database_model].mapping.mappings)
+        .to_equal(mappings)
+    end
+  end
+
+  describe ".add_mappings" do
+    before do
+      database_model.map_to(salesforce_model)
+      database_model.add_mappings(mappings)
+    end
+
+    it "applies the passed attribute mappings to the registered RecordType" do
+      expect(Restforce::DB::RecordType[database_model].mapping.mappings)
+        .to_equal(mappings)
+    end
+  end
+
+end

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

@@ -0,0 +1,26 @@
+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

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

@@ -0,0 +1,85 @@
+require_relative "../../../../test_helper"
+
+describe Restforce::DB::RecordTypes::ActiveRecord do
+
+  configure!
+
+  let(:mapping) { Restforce::DB::Mapping.new }
+  let(:record_type) { Restforce::DB::RecordTypes::ActiveRecord.new(CustomObject, mapping) }
+  let(:salesforce_id) { "a001a000001E1vREAL" }
+
+  describe "#sync!" do
+    let(:sync_from) do
+      Struct.new(:id, :attributes).new(
+        salesforce_id,
+        name:    "Some name",
+        example: "Some text",
+      )
+    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
+        expect(instance.salesforce_id).to_equal salesforce_id
+        expect(instance.name).to_equal sync_from.attributes[:name]
+        expect(instance.example).to_equal sync_from.attributes[:example]
+      end
+    end
+
+    describe "with an existing database record" do
+      let(:sync_to) do
+        CustomObject.create!(
+          name: "Existing name",
+          example: "Existing sample text",
+          salesforce_id: salesforce_id,
+        )
+      end
+
+      before { sync_to }
+
+      it "updates the existing database record" do
+        expect(instance).to_equal sync_to.reload
+        expect(instance.name).to_equal sync_from.attributes[:name]
+        expect(instance.example).to_equal sync_from.attributes[:example]
+      end
+    end
+  end
+
+  describe "#create!" do
+    let(:create_from) do
+      Struct.new(:id, :attributes).new(
+        salesforce_id,
+        name:    "Some name",
+        example: "Some text",
+      )
+    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]
+    end
+  end
+
+  describe "#find" do
+
+    it "finds existing records in the database by their salesforce id" do
+      CustomObject.create!(salesforce_id: salesforce_id)
+      expect(record_type.find(salesforce_id)).to_be_instance_of Restforce::DB::Instances::ActiveRecord
+    end
+
+    it "returns nil when no matching record exists" do
+      expect(record_type.find("a001a000001E1vFAKE")).to_be_nil
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require_relative "../../../../test_helper"
+
+describe Restforce::DB::RecordTypes::Salesforce do
+
+  configure!
+
+  let(:mapping) { Restforce::DB::Mapping.new }
+  let(:record_type) { Restforce::DB::RecordTypes::Salesforce.new("CustomObject__c", mapping) }
+
+  describe "#create!", :vcr do
+    let(:database_record) do
+      CustomObject.create!(
+        name: "Something",
+        example: "Something else",
+      )
+    end
+    let(:sync_from) { Restforce::DB::Instances::ActiveRecord.new(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]
+    end
+
+    it "creates a record in Salesforce from the passed database record's attributes" do
+      expect(instance.Name).to_equal database_record.name
+      expect(instance.Example_Field__c).to_equal database_record.example
+    end
+
+    it "updates the database record with the Salesforce record's ID" do
+      expect(sync_from.synced?).to_equal(true)
+    end
+  end
+
+  describe "#find", :vcr do
+    let(:id) { Salesforce.create!("CustomObject__c") }
+
+    it "finds existing records in Salesforce" do
+      expect(record_type.find(id)).to_be_instance_of Restforce::DB::Instances::Salesforce
+    end
+
+    it "returns nil when no matching record exists" do
+      expect(record_type.find("a001a000001E1vFAKE")).to_be_nil
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+require_relative "../../../test_helper"
+
+describe Restforce::DB::Synchronizer do
+
+  configure!
+
+  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) }
+
+  describe "#run", vcr: { match_requests_on: [:method, VCR.request_matchers.uri_without_param(:q)] } do
+    let(:attributes) do
+      {
+        name:    "Custom object",
+        example: "Some sample text",
+      }
+    end
+    let(:salesforce_id) do
+      Salesforce.create!(
+        "CustomObject__c",
+        mapping.convert(:salesforce, 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
+
+        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 "given an existing database record" do
+      let(:database_record) { CustomObject.create!(attributes) }
+      let(:salesforce_id) { database_record.reload.salesforce_id }
+
+      before do
+        database_record
+        synchronizer.run
+
+        Salesforce.records << ["CustomObject__c", salesforce_id]
+      end
+
+      it "populates Salesforce with the new record" do
+        record = salesforce_type.find(salesforce_id).record
+
+        expect(record.Name).to_equal attributes[:name]
+        expect(record.Example_Field__c).to_equal attributes[:example]
+      end
+    end
+
+    describe "given a Salesforce record with an existing record in the database" do
+      let(:database_record) do
+        CustomObject.create!(
+          name:          "Some existing name",
+          example:       "Some existing sample text",
+          salesforce_id: salesforce_id,
+        )
+      end
+
+      before do
+        database_record
+        salesforce_id
+        synchronizer.run
+      end
+
+      it "updates the database record" do
+        record = database_record.reload
+
+        expect(record.name).to_equal attributes[:name]
+        expect(record.example).to_equal attributes[:example]
+      end
+    end
+
+  end
+end

data/test/lib/restforce/db_test.rb

@@ -0,0 +1,24 @@
+require_relative "../../test_helper"
+
+describe Restforce::DB do
+
+  configure!
+
+  describe "#configure" do
+
+    it "yields a Configuration" do
+      Restforce::DB.configure do |config|
+        expect(config).to_be_instance_of(Restforce::DB::Configuration)
+      end
+    end
+  end
+
+  describe "accessing Salesforce", :vcr do
+
+    it "uses the configured credentials" do
+      expect(Restforce::DB.client.authenticate!.access_token).to_not_be_nil
+    end
+
+  end
+
+end

data/test/support/active_record.rb

@@ -0,0 +1,20 @@
+require "active_record"
+
+ActiveRecord::Base.logger = Logger.new("/dev/null")
+ActiveRecord::Base.establish_connection(
+  adapter: "sqlite3",
+  database: ":memory:",
+)
+
+ActiveRecord::Schema.define do
+  create_table :custom_objects do |table|
+    table.column :name,          :string
+    table.column :example,       :string
+    table.column :salesforce_id, :string
+    table.timestamps null: false
+  end
+
+  add_index :custom_objects, :salesforce_id
+end
+
+class CustomObject < ActiveRecord::Base; end

data/test/support/database_cleaner.rb

@@ -0,0 +1,3 @@
+require "database_cleaner"
+
+DatabaseCleaner.strategy = :truncation

data/test/support/salesforce.rb

@@ -0,0 +1,48 @@
+# A small utility class to allow for transactional Salesforce record creation.
+class Salesforce
+
+  class << self
+
+    attr_accessor :records
+
+  end
+
+  self.records = []
+
+  # Public: Configure Restforce::DB for purposes of test execution.
+  #
+  # Returns nothing.
+  def self.configure!
+    Restforce::DB.configure { |config| config.load(Secrets["client"]) }
+  end
+
+  # Public: Create a basic instance of the passed Salesforce model.
+  #
+  # salesforce_model - The name of the model which should be created.
+  # attributes       - A Hash of attributes to assign to the created object.
+  #
+  # 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.records << [salesforce_model, salesforce_id]
+
+    salesforce_id
+  end
+
+  # Public: Clean up any data which was added to Salesforce during the current
+  # test run. For consistency in our tests, we reset the configuration and discard
+  # our current client session each time this method is run.
+  #
+  # Returns nothing.
+  def self.clean!
+    # raise Salesforce.records.inspect unless Salesforce.records.empty?
+    Salesforce.records.each do |entry|
+      Restforce::DB.client.destroy entry[0], entry[1]
+    end
+    Salesforce.records = []
+
+    Restforce::DB.reset
+  end
+
+end

data/test/support/vcr.rb

@@ -0,0 +1,23 @@
+require "minitest-vcr"
+require "vcr"
+require "webmock"
+
+VCR.configure do |c|
+  c.cassette_library_dir = "test/cassettes"
+  c.hook_into :webmock
+
+  %w(
+    username
+    password
+    security_token
+    client_id
+    client_secret
+    host
+  ).each do |secret|
+    c.filter_sensitive_data("<#{secret}>") do
+      CGI.escape(Secrets["client"][secret])
+    end
+  end
+end
+
+MinitestVcr::Spec.configure!

data/test/test_helper.rb

@@ -0,0 +1,25 @@
+require "cgi"
+require "minitest/autorun"
+require "minitest/bang"
+require "minitest/spec/expect"
+require "yaml"
+
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require "restforce/db"
+
+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