openstax_active_force 1.0.0

data/spec/active_force/sobject_spec.rb

@@ -0,0 +1,398 @@
+require 'spec_helper'
+
+describe ActiveForce::SObject do
+  let(:sobject_hash) { YAML.load(fixture('sobject/single_sobject_hash')) }
+  let(:client) { double 'Client' }
+
+  before do
+    ActiveForce.sfdc_client = client
+  end
+
+  describe ".new" do
+    it 'should assigns values when are passed by parameters' do
+      expect(Whizbang.new({ text: 'some text' }).text).to eq 'some text'
+    end
+  end
+
+  describe ".build" do
+    let(:sobject){ Whizbang.build sobject_hash }
+
+    it "build a valid sobject from a JSON" do
+      expect(sobject).to be_an_instance_of Whizbang
+    end
+
+    it "sets the values' types from the sf_type" do
+      expect(sobject.boolean).to be_an_instance_of TrueClass
+      expect(sobject.checkbox).to be_an_instance_of FalseClass
+      expect(sobject.date).to be_an_instance_of Date
+      expect(sobject.datetime).to be_an_instance_of DateTime
+      expect(sobject.percent).to be_an_instance_of Float
+      expect(sobject.text).to be_an_instance_of String
+      expect(sobject.picklist_multiselect).to be_an_instance_of String
+    end
+  end
+
+  describe ".field" do
+    it "add a mappings" do
+      expect(Whizbang.mappings).to include(
+        checkbox: 'Checkbox_Label',
+        text: 'Text_Label',
+        date: 'Date_Label',
+        datetime: 'DateTime_Label',
+        picklist_multiselect: 'Picklist_Multiselect_Label'
+      )
+    end
+
+    it "set an attribute" do
+      %w[checkbox text date datetime picklist_multiselect].each do |name|
+        expect(Whizbang.attribute_names).to include(name)
+      end
+    end
+
+    it "uses Salesforce API naming conventions by default" do
+      expect(Whizbang.mappings[:estimated_close_date]).to eq 'Estimated_Close_Date__c'
+    end
+
+    describe 'having an id' do
+      it 'has one by default' do
+        expect(Territory.new).to respond_to(:id)
+        expect(Territory.mappings[:id]).to eq 'Id'
+      end
+
+      it 'can be overridden' do
+        expect(Quota.new).to respond_to(:id)
+        expect(Quota.mappings[:id]).to eq 'Bar_Id__c'
+      end
+    end
+
+    context 'as: :multi_picklist' do
+      before do
+        class IceCream < ActiveForce::SObject
+          field :flavors, as: :multi_picklist
+        end
+        sundae.clear_changes_information
+        sundae.flavors = %w(chocolate vanilla strawberry)
+      end
+
+      context 'on create' do
+        let(:sundae) { IceCream.new }
+        it 'formats the picklist values' do
+          expect(client).to receive(:create!).with('IceCream__c', {'Flavors__c' => 'chocolate;vanilla;strawberry'})
+          sundae.save
+        end
+      end
+
+      context 'on update' do
+        let(:sundae) { IceCream.new(id: '1') }
+        it 'formats the picklist values' do
+          expect(client).to receive(:update!).with('IceCream__c', {'Flavors__c' => 'chocolate;vanilla;strawberry', 'Id' => '1'})
+          sundae.save
+        end
+      end
+
+    end
+  end
+
+  describe "CRUD" do
+    let(:instance){ Whizbang.new(id: '1') }
+
+    describe '#update' do
+
+      context 'with valid attributes' do
+        before do
+          expected_args = [
+            Whizbang.table_name,
+            {'Text_Label' => 'some text', 'Boolean_Label' => false, 'Id' => '1', "Updated_From__c"=>"Rails"}
+          ]
+          expect(client).to receive(:update!).with(*expected_args).and_return('id')
+        end
+
+        it 'delegates to the Client with create! and sets the id' do
+          expect(instance.update( text: 'some text', boolean: false )).to eq(true)
+          expect(instance.text).to eq('some text')
+        end
+      end
+
+      context 'with invalid attributes' do
+        it 'sets the error on the instance' do
+          expect(instance.update( boolean: true )).to eq(false)
+          expect(instance.errors).to be_present
+          expect(instance.errors.full_messages.count).to eq(1)
+          expect(instance.errors.full_messages[0]).to eq("Percent can't be blank")
+        end
+      end
+    end
+
+    describe ".update!" do
+      context 'with valid attributes' do
+        describe 'and without a ClientError' do
+          before do
+            expected_args = [
+              Whizbang.table_name,
+              {'Text_Label' => 'some text', 'Boolean_Label' => false, 'Id' => '1', "Updated_From__c"=>"Rails"}
+            ]
+            expect(client).to receive(:update!).with(*expected_args).and_return('id')
+          end
+          it 'saves successfully' do
+            expect(instance.update!( text: 'some text', boolean: false )).to eq(true)
+            expect(instance.text).to eq('some text')
+          end
+        end
+
+        describe 'and with a ClientError' do
+          let(:faraday_error){ Faraday::Error::ClientError.new('Some String') }
+
+          before{ expect(client).to receive(:update!).and_raise(faraday_error) }
+
+          it 'raises an error' do
+            expect{ instance.update!( text: 'some text', boolean: false ) }.to raise_error(Faraday::Error::ClientError)
+          end
+        end
+      end
+
+      context 'with invalid attributes' do
+        let(:instance){ Whizbang.new boolean: true }
+
+        it 'raises an error' do
+          expect{ instance.update!( text: 'some text', boolean: true ) }.to raise_error(ActiveForce::RecordInvalid)
+        end
+      end
+    end
+
+    describe '#create' do
+      context 'with valid attributes' do
+        before do
+          expect(client).to receive(:create!).and_return('id')
+        end
+
+        it 'delegates to the Client with create! and sets the id' do
+          expect(instance.create).to be_instance_of(Whizbang)
+          expect(instance.id).to eq('id')
+        end
+      end
+
+
+      context 'with invalid attributes' do
+        let(:instance){ Whizbang.new boolean: true }
+
+        it 'sets the error on the instance' do
+          expect(instance.create).to be_instance_of(Whizbang)
+          expect(instance.id).to eq(nil)
+          expect(instance.errors).to be_present
+          expect(instance.errors.full_messages.count).to eq(1)
+          expect(instance.errors.full_messages[0]).to eq("Percent can't be blank")
+        end
+      end
+    end
+
+    describe '#create!' do
+      context 'with valid attributes' do
+        describe 'and without a ClientError' do
+
+          before{ expect(client).to receive(:create!).and_return('id') }
+
+          it 'saves successfully' do
+            expect(instance.create!).to be_instance_of(Whizbang)
+            expect(instance.id).to eq('id')
+          end
+        end
+
+        describe 'and with a ClientError' do
+          let(:faraday_error){ Faraday::Error::ClientError.new('Some String') }
+
+          before{ expect(client).to receive(:create!).and_raise(faraday_error) }
+
+          it 'raises an error' do
+            expect{ instance.create! }.to raise_error(Faraday::Error::ClientError)
+          end
+        end
+      end
+
+      context 'with invalid attributes' do
+        let(:instance){ Whizbang.new boolean: true }
+
+        it 'raises an error' do
+          expect{ instance.create! }.to raise_error(ActiveForce::RecordInvalid)
+        end
+      end
+    end
+
+    describe "#destroy" do
+      it "should send client :destroy! with its id" do
+        expect(client).to receive(:destroy!).with 'Whizbang__c', '1'
+        instance.destroy
+      end
+    end
+
+    describe 'self.create' do
+      before do
+        expect(client).to receive(:create!).with(Whizbang.table_name, 'Text_Label' => 'some text', 'Updated_From__c'=>'Rails').and_return('id')
+      end
+
+      it 'should create a new instance' do
+        expect(Whizbang.create(text: 'some text')).to be_instance_of(Whizbang)
+      end
+    end
+  end
+
+  describe "#count" do
+    let(:count_response){ [Restforce::Mash.new(expr0: 1)] }
+
+    it "responds to count" do
+      expect(Whizbang).to respond_to(:count)
+    end
+
+    it "sends the query to the client" do
+      expect(client).to receive(:query).and_return(count_response)
+      expect(Whizbang.count).to eq(1)
+    end
+
+  end
+
+  describe "#find_by" do
+    it "should query the client, with the SFDC field names and correctly enclosed values" do
+      expect(client).to receive(:query).with("SELECT #{Whizbang.fields.join ', '} FROM Whizbang__c WHERE (Id = 123) AND (Text_Label = 'foo') LIMIT 1")
+      Whizbang.find_by id: 123, text: "foo"
+    end
+  end
+
+  describe '#reload' do
+    let(:client) do
+      double("sfdc_client", query: [Restforce::Mash.new(Id: 1, Name: 'Jeff')])
+    end
+    let(:quota){ Quota.new(id: '1') }
+    let(:territory){ Territory.new(id: '1', quota_id: '1') }
+
+    before do
+      ActiveForce.sfdc_client = client
+    end
+
+    it 'clears cached associations' do
+      soql = "SELECT Id, Bar_Id__c FROM Quota__c WHERE (Id = '1') LIMIT 1"
+      expect(client).to receive(:query).twice.with soql
+      allow(Territory).to receive(:find){ territory }
+      territory.quota
+      territory.quota
+      territory.reload
+      territory.quota
+    end
+
+    it "refreshes the object's attributes" do
+      territory.name = 'Walter'
+      expect(territory.name).to eq 'Walter'
+      territory.reload
+      expect(territory.name).to eq 'Jeff'
+      expect(territory.changed_attributes).to be_empty
+    end
+
+    it 'returns the same object' do
+      allow(Territory).to receive(:find){ Territory.new }
+      expected = territory
+      expect(territory.reload).to eql expected
+    end
+  end
+
+  describe '#persisted?' do
+    context 'with an id' do
+      let(:instance){ Territory.new(id: '00QV0000004jeqNMAT') }
+
+      it 'returns true' do
+        expect(instance).to be_persisted
+      end
+    end
+
+    context 'without an id' do
+      let(:instance){ Territory.new }
+
+      it 'returns false' do
+        expect(instance).to_not be_persisted
+      end
+    end
+  end
+
+  describe 'logger output' do
+    let(:instance){ Whizbang.new }
+
+    before do
+      allow(instance).to receive(:create!).and_raise(Faraday::Error::ClientError.new(double))
+    end
+
+    it 'catches and logs the error' do
+      expect(instance).to receive(:logger_output).and_return(false)
+      instance.save
+    end
+  end
+
+  describe ".save!" do
+    let(:instance){ Whizbang.new }
+
+    context 'with valid attributes' do
+      describe 'and without a ClientError' do
+        before{ expect(client).to receive(:create!).and_return('id') }
+        it 'saves successfully' do
+          expect(instance.save!).to eq(true)
+        end
+      end
+
+      describe 'and with a ClientError' do
+        let(:faraday_error){ Faraday::Error::ClientError.new('Some String') }
+
+        before{ expect(client).to receive(:create!).and_raise(faraday_error) }
+
+        it 'raises an error' do
+          expect{ instance.save! }.to raise_error(Faraday::Error::ClientError)
+        end
+      end
+    end
+
+    context 'with invalid attributes' do
+      let(:instance){ Whizbang.new boolean: true }
+
+      it 'raises an error' do
+        expect{ instance.save! }.to raise_error(ActiveForce::RecordInvalid)
+      end
+    end
+  end
+
+  describe ".save" do
+    let(:instance){ Whizbang.new }
+
+    context 'with valid attributes' do
+      describe 'and without a ClientError' do
+        before{ expect(client).to receive(:create!).and_return('id') }
+        it 'saves successfully' do
+          expect(instance.save).to eq(true)
+        end
+      end
+
+      describe 'and with a ClientError' do
+        let(:faraday_error){ Faraday::Error::ClientError.new('Some String') }
+        before{ expect(client).to receive(:create!).and_raise(faraday_error) }
+        it 'returns false' do
+          expect(instance.save).to eq(false)
+        end
+        it 'sets the error on the instance' do
+          instance.save
+          expect(instance.errors).to be_present
+          expect(instance.errors.full_messages.count).to eq(1)
+          expect(instance.errors.full_messages[0]).to eq('Some String')
+        end
+      end
+    end
+
+    context 'with invalid attributes' do
+      let(:instance){ Whizbang.new boolean: true }
+
+      it 'does not save' do
+        expect(instance.save).to eq(false)
+      end
+
+      it 'sets the error on the instance' do
+        instance.save
+        expect(instance.errors).to be_present
+        expect(instance.errors.full_messages.count).to eq(1)
+        expect(instance.errors.full_messages[0]).to eq("Percent can't be blank")
+      end
+    end
+  end
+end

data/spec/active_force/table_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe ActiveForce::Table do
+  describe '#table_name' do
+    let(:table) { ActiveForce::Table }
+
+    it 'Use the class name adding "__c"' do
+      expect(table.new('Custom').name).to eq('Custom__c')
+    end
+
+    it 'with standard SObject types it does not add the "__c"' do
+      expect(table.new('Account').name).to eq('Account')
+    end
+
+    context 'with a namespace' do
+      it "the namespace is not included" do
+        expect(table.new('Foo::Bar').name).to eq('Bar__c')
+      end
+
+      it 'standard types are inferred correctly' do
+        expect(table.new('Foo::Account').name).to eq('Account')
+      end
+    end
+  end
+end

data/spec/active_force_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe ActiveForce do
+  it 'should have a version number' do
+    expect(ActiveForce::VERSION).to_not be_nil
+  end
+end

data/spec/fixtures/sobject/single_sobject_hash.yml

@@ -0,0 +1,26 @@
+attributes:
+  type: 'Whizbang'
+  url: '/services/data/v20.0/sobjects/Whizbang/foo'
+Checkbox_Label: false
+Text_Label: 'Hi there!'
+Date_Label: '2010-01-01'
+DateTime_Label: '2011-07-07T00:37:00.000+0000'
+Picklist_Multiselect_Label: 'four;six'
+Percent_Label: 20
+Boolean_Label: true
+
+ParentWhizbang__r:
+  Name: 'Parent Whizbang'
+  Text_Label: 'Hello'
+  attributes:
+    type: 'Whizbang'
+    url: '/services/data/v20.0/sobjects/Whizbang/bar'
+
+Whizbangs__r:
+  totalSize: 1
+  done: true
+  records:
+    - attributes:
+        type: 'Whizbang__c'
+        url: '/services/data/v24.0/sobjects/Whizbang__c/a00E0000004D5lsIAC'
+      Name: 'Child Whizbang'

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'active_force'
+Dir["./spec/support/**/*"].sort.each { |f| require f }
+require 'pry'
+
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.plural 'quota', 'quotas'
+  inflect.plural 'Quota', 'Quotas'
+  inflect.singular 'quota', 'quota'
+  inflect.singular 'Quota', 'Quota'
+end
+
+RSpec.configure do |config|
+  config.order = :random
+  config.include RestforceFactories
+end

data/spec/support/fixture_helpers.rb

@@ -0,0 +1,45 @@
+module FixtureHelpers
+  module InstanceMethods
+
+    def stub_api_request(endpoint, options={})
+      options = {
+        :method => :get,
+        :status => 200,
+        :api_version => Restforce.configuration.api_version
+      }.merge(options)
+
+      stub = stub_request(options[:method], %r{/services/data/v#{options[:api_version]}/#{endpoint}})
+      stub = stub.with(:body => options[:with_body]) if options[:with_body] && !RUBY_VERSION.match(/^1.8/)
+      stub = stub.to_return(:status => options[:status], :body => fixture(options[:fixture]), :headers => { 'Content-Type' => 'application/json'}) if options[:fixture]
+      stub
+    end
+
+    def stub_login_request(options={})
+      stub = stub_request(:post, "https://login.salesforce.com/services/oauth2/token")
+      stub = stub.with(:body => options[:with_body]) if options[:with_body] && !RUBY_VERSION.match(/^1.8/)
+      stub
+    end
+
+    def fixture(f)
+      File.read(File.expand_path("../../fixtures/#{f}.yml", __FILE__))
+    end
+
+  end
+
+  module ClassMethods
+    def requests(endpoint, options={})
+      before do
+        (@requests ||= []) << stub_api_request(endpoint, options)
+      end
+
+      after do
+        @requests.each { |request| expect(request).to have_been_requested }
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include FixtureHelpers::InstanceMethods
+  config.extend FixtureHelpers::ClassMethods
+end

data/spec/support/restforce_factories.rb

@@ -0,0 +1,9 @@
+module RestforceFactories
+  def build_restforce_collection(array)
+    Restforce::Collection.new({ 'records' => array }, nil)
+  end
+
+  def build_restforce_sobject(hash)
+    Restforce::SObject.new(hash)
+  end
+end

data/spec/support/sobjects.rb

@@ -0,0 +1,97 @@
+
+class Comment < ActiveForce::SObject
+  self.table_name = "Comment__c"
+  field :post_id, from: "PostId"
+  field :poster_id, from: 'PosterId__c'
+  field :fancy_post_id, from: 'FancyPostId'
+  field :body
+  belongs_to :post
+end
+class Post < ActiveForce::SObject
+  self.table_name = "Post__c"
+  field :title
+  has_many :comments
+  has_many :impossible_comments, model: Comment, scoped_as: ->{ where('1 = 0') }
+  has_many :reply_comments, model: Comment, scoped_as: ->(post){ where(body: "RE: #{post.title}").order('CreationDate DESC') }
+  has_many :ugly_comments, { model: Comment }
+  has_many :poster_comments, { foreign_key: :poster_id, model: Comment }
+end
+class Territory < ActiveForce::SObject
+  field :quota_id, from: "Quota__c"
+  field :name, from: 'Name'
+  belongs_to :quota
+end
+class PrezClub < ActiveForce::SObject
+  field :quota_id, from: 'QuotaId'
+  belongs_to :quota
+end
+class Quota < ActiveForce::SObject
+  field :id, from: 'Bar_Id__c'
+  has_many :prez_clubs
+  has_many :territories
+end
+class Opportunity < ActiveForce::SObject
+  field :account_id, from: 'AccountId'
+  belongs_to :account
+end
+class Account < ActiveForce::SObject
+  field :owner_id, from: 'OwnerId'
+  has_many :opportunities
+  belongs_to :owner
+end
+class Owner < ActiveForce::SObject
+  has_many :accounts
+end
+class Custom < ActiveForce::SObject; end
+class EnforcedTableName < ActiveForce::SObject
+  self.table_name = 'Forced__c'
+end
+
+module Foo
+  class Bar < ActiveForce::SObject; end
+  class Opportunity < ActiveForce::SObject
+    field :account_id, from: 'AccountId'
+    field :partner_account_id, from: 'Partner_Account_Id__c'
+  end
+  class Account < ActiveForce::SObject
+    has_many :opportunities, model: Foo::Opportunity
+    has_many :partner_opportunities, foreign_key: :partner_account_id, model: Foo::Opportunity
+  end
+  class Lead < ActiveForce::SObject; end
+  class Attachment < ActiveForce::SObject
+    field :lead_id, from: 'Lead_Id__c'
+    field :fancy_lead_id, from: 'LeadId'
+    belongs_to :lead, model: Foo::Lead
+    belongs_to :fancy_lead, model: Foo::Lead, foreign_key: :fancy_lead_id
+  end
+end
+
+module Salesforce
+  class PrezClub < ActiveForce::SObject
+    field :quota_id, from: 'QuotaId'
+  end
+  class Quota < ActiveForce::SObject
+    has_many :prez_clubs, model: PrezClub
+  end
+  class Widget < ActiveForce::SObject
+    self.table_name = 'Tegdiw__c'
+  end
+  class Territory < ActiveForce::SObject
+    field :quota_id, from: "QuotaId"
+    field :widget_id, from: 'WidgetId'
+    belongs_to :quota, model: Salesforce::Quota, foreign_key: :quota_id
+    belongs_to :widget, model: Salesforce::Widget, foreign_key: :widget_id
+  end
+  class User < ActiveForce::SObject
+  end
+  class Opportunity < ActiveForce::SObject
+    field :owner_id, from: 'OwnerId'
+    field :account_id, from: 'AccountId'
+    field :business_partner
+    belongs_to :owner, model: Salesforce::User, foreign_key: :owner_id, relationship_name: 'Owner'
+  end
+  class Account < ActiveForce::SObject
+    field :business_partner
+    has_many :partner_opportunities, model: Opportunity, scoped_as: ->(account){ where(business_partner: account.business_partner).includes(:owner) }
+  end
+end

data/spec/support/whizbang.rb

@@ -0,0 +1,30 @@
+class Whizbang < ActiveForce::SObject
+
+  field :id,                   from: 'Id'
+  field :checkbox,             from: 'Checkbox_Label', as: :boolean
+  field :text,                 from: 'Text_Label'
+  field :date,                 from: 'Date_Label', as: :date
+  field :datetime,             from: 'DateTime_Label', as: :datetime
+  field :picklist_multiselect, from: 'Picklist_Multiselect_Label', as: :multipicklist
+  field :boolean,              from: 'Boolean_Label',  as: :boolean
+  field :percent,              from: 'Percent_Label',  as: :percent
+  field :estimated_close_date, as: :datetime
+  field :updated_from,         as: :datetime
+  field :dirty_attribute,      as: :boolean
+
+  before_save :set_as_updated_from_rails
+  after_save :mark_dirty
+
+  validates :percent, presence: true, if: :boolean
+
+  private
+
+  def set_as_updated_from_rails
+    self.updated_from = 'Rails'
+  end
+
+  def mark_dirty
+    self.dirty_attribute = true
+  end
+
+end