fat_free_crm 0.13.6 → 0.14.0

data/spec/mailers/user_mailer_spec.rb

@@ -6,134 +6,133 @@
 require 'spec_helper'
 
 describe UserMailer do
-
   describe "password_reset_instructions" do
-    let(:user) { FactoryGirl.create(:user, :email => "forgot_my_password@example.com") }
+    let(:user) { FactoryGirl.create(:user, email: "forgot_my_password@example.com") }
     let(:mail) { UserMailer.password_reset_instructions(user) }
 
     before(:each) do
-      I18n.stub(:t).with(:password_reset_instruction).and_return("Password Reset Instructions")
-      user.stub(:perishable_token).and_return("62fe5299b45513f9d22a2e1454f35dd43d62ba50")
+      allow(I18n).to receive(:t).with(:password_reset_instruction).and_return("Password Reset Instructions")
+      allow(user).to receive(:perishable_token).and_return("62fe5299b45513f9d22a2e1454f35dd43d62ba50")
     end
 
     it "sets fatfree as the sender" do
-      mail.from.should eql(["noreply@fatfreecrm.com"])
+      expect(mail.from).to eql(["noreply@fatfreecrm.com"])
     end
 
     it "sets user 'forgot_my_password@example.com' as recipient" do
-      mail.to.should eq(["forgot_my_password@example.com"])
+      expect(mail.to).to eq(["forgot_my_password@example.com"])
     end
 
     it "sets the subject" do
-      mail.subject.should eq("Fat Free CRM: Password Reset Instructions")
+      expect(mail.subject).to eq("Fat Free CRM: Password Reset Instructions")
     end
 
     it "includes password reset link in body" do
-      mail.body.encoded.should match("http://www.example.com/passwords/62fe5299b45513f9d22a2e1454f35dd43d62ba50/edit")
+      expect(mail.body.encoded).to match("http://www.example.com/passwords/62fe5299b45513f9d22a2e1454f35dd43d62ba50/edit")
     end
   end
 
   describe "assigned_entity_notification" do
-    let(:assigner) { FactoryGirl.create(:user, :first_name => "Bob", :last_name => "Hope") }
-    let(:assignee) { FactoryGirl.create(:user, :email => "assignee@example.com") }
+    let(:assigner) { FactoryGirl.create(:user, first_name: "Bob", last_name: "Hope") }
+    let(:assignee) { FactoryGirl.create(:user, email: "assignee@example.com") }
 
     context "for an account" do
-      let(:account) { FactoryGirl.create(:account, :id => 16, :name => 'Ghostbusters', :user => assigner, :assignee => assignee) }
+      let(:account) { FactoryGirl.create(:account, id: 16, name: 'Ghostbusters', user: assigner, assignee: assignee) }
       let(:mail) { UserMailer.assigned_entity_notification(account, assigner) }
 
       it "sets fatfree as the sender" do
-        mail.from.should eql(["noreply@fatfreecrm.com"])
+        expect(mail.from).to eql(["noreply@fatfreecrm.com"])
       end
 
       it "sets user 'assignee@example.com' as recipient" do
-        mail.to.should eq(["assignee@example.com"])
+        expect(mail.to).to eq(["assignee@example.com"])
       end
 
       it "sets the subject" do
-        mail.subject.should eq("Fat Free CRM: You have been assigned Ghostbusters Account")
+        expect(mail.subject).to eq("Fat Free CRM: You have been assigned Ghostbusters Account")
       end
 
       it "includes the name of the person who re-assigned the lead in the body" do
-        mail.body.encoded.should match("Bob")
+        expect(mail.body.encoded).to match("Bob")
       end
 
       it "includes link to the lead in the body" do
-        mail.body.encoded.should match("http://www.example.com/accounts/16")
+        expect(mail.body.encoded).to match("http://www.example.com/accounts/16")
       end
     end
 
     context "for a contact" do
-      let(:contact) { FactoryGirl.create(:contact, :id => 56, :first_name => 'Harold', :last_name => 'Ramis', :user => assigner, :assignee => assignee) }
+      let(:contact) { FactoryGirl.create(:contact, id: 56, first_name: 'Harold', last_name: 'Ramis', user: assigner, assignee: assignee) }
       let(:mail) { UserMailer.assigned_entity_notification(contact, assigner) }
 
       it "sets fatfree as the sender" do
-        mail.from.should eql(["noreply@fatfreecrm.com"])
+        expect(mail.from).to eql(["noreply@fatfreecrm.com"])
       end
 
       it "sets user 'assignee@example.com' as recipient" do
-        mail.to.should eq(["assignee@example.com"])
+        expect(mail.to).to eq(["assignee@example.com"])
       end
 
       it "sets the subject" do
-        mail.subject.should eq("Fat Free CRM: You have been assigned Harold Ramis Contact")
+        expect(mail.subject).to eq("Fat Free CRM: You have been assigned Harold Ramis Contact")
       end
 
       it "includes the name of the person who re-assigned the lead in the body" do
-        mail.body.encoded.should match("Bob")
+        expect(mail.body.encoded).to match("Bob")
       end
 
       it "includes link to the lead in the body" do
-        mail.body.encoded.should match("http://www.example.com/contacts/56")
+        expect(mail.body.encoded).to match("http://www.example.com/contacts/56")
       end
     end
 
     context "for a lead" do
-      let(:lead) { FactoryGirl.create(:lead, :id => 42, :first_name => 'Bill', :last_name => 'Murray', :user => assigner, :assignee => assignee) }
+      let(:lead) { FactoryGirl.create(:lead, id: 42, first_name: 'Bill', last_name: 'Murray', user: assigner, assignee: assignee) }
       let(:mail) { UserMailer.assigned_entity_notification(lead, assigner) }
 
       it "sets fatfree as the sender" do
-        mail.from.should eql(["noreply@fatfreecrm.com"])
+        expect(mail.from).to eql(["noreply@fatfreecrm.com"])
       end
 
       it "sets user 'assignee@example.com' as recipient" do
-        mail.to.should eq(["assignee@example.com"])
+        expect(mail.to).to eq(["assignee@example.com"])
       end
 
       it "sets the subject" do
-        mail.subject.should eq("Fat Free CRM: You have been assigned Bill Murray Lead")
+        expect(mail.subject).to eq("Fat Free CRM: You have been assigned Bill Murray Lead")
       end
 
       it "includes the name of the person who re-assigned the lead in the body" do
-        mail.body.encoded.should match("Bob")
+        expect(mail.body.encoded).to match("Bob")
       end
 
       it "includes link to the lead in the body" do
-        mail.body.encoded.should match("http://www.example.com/leads/42")
+        expect(mail.body.encoded).to match("http://www.example.com/leads/42")
       end
     end
 
     context "for an opportunity" do
-      let(:opportunity) { FactoryGirl.create(:opportunity, :id => 24, :name => 'Big', :user => assigner, :assignee => assignee) }
+      let(:opportunity) { FactoryGirl.create(:opportunity, id: 24, name: 'Big', user: assigner, assignee: assignee) }
       let(:mail) { UserMailer.assigned_entity_notification(opportunity, assigner) }
 
       it "sets fatfree as the sender" do
-        mail.from.should eql(["noreply@fatfreecrm.com"])
+        expect(mail.from).to eql(["noreply@fatfreecrm.com"])
       end
 
       it "sets user 'assignee@example.com' as recipient" do
-        mail.to.should eq(["assignee@example.com"])
+        expect(mail.to).to eq(["assignee@example.com"])
       end
 
       it "sets the subject" do
-        mail.subject.should eq("Fat Free CRM: You have been assigned Big Opportunity")
+        expect(mail.subject).to eq("Fat Free CRM: You have been assigned Big Opportunity")
       end
 
       it "includes the name of the person who re-assigned the lead in the body" do
-        mail.body.encoded.should match("Bob")
+        expect(mail.body.encoded).to match("Bob")
       end
 
       it "includes link to the lead in the body" do
-        mail.body.encoded.should match("http://www.example.com/opportunities/24")
+        expect(mail.body.encoded).to match("http://www.example.com/opportunities/24")
       end
     end
   end

data/spec/models/entities/account_contact_spec.rb

@@ -20,8 +20,8 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 describe AccountContact do
   before(:each) do
     @valid_attributes = {
-      :account => mock_model(Account),
-      :contact => mock_model(Contact)
+      account: mock_model(Account),
+      contact: mock_model(Contact)
     }
   end
 
@@ -29,4 +29,3 @@ describe AccountContact do
     AccountContact.create!(@valid_attributes)
   end
 end
-

data/spec/models/entities/account_opportunity_spec.rb

@@ -20,8 +20,8 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 describe AccountOpportunity do
   before(:each) do
     @valid_attributes = {
-      :account => mock_model(Account),
-      :opportunity => mock_model(Opportunity)
+      account: mock_model(Account),
+      opportunity: mock_model(Opportunity)
     }
   end
 
@@ -29,4 +29,3 @@ describe AccountOpportunity do
     AccountOpportunity.create!(@valid_attributes)
   end
 end
-

data/spec/models/entities/account_spec.rb

@@ -28,11 +28,10 @@
 require 'spec_helper'
 
 describe Account do
-
   before { login }
 
   it "should create a new instance given valid attributes" do
-    Account.create!(:name => "Test Account", :user => FactoryGirl.create(:user))
+    Account.create!(name: "Test Account", user: FactoryGirl.create(:user))
   end
 
   describe "Attach" do
@@ -41,25 +40,25 @@ describe Account do
     end
 
     it "should return nil when attaching existing asset" do
-      @task = FactoryGirl.create(:task, :asset => @account, :user => current_user)
+      @task = FactoryGirl.create(:task, asset: @account, user: current_user)
       @contact = FactoryGirl.create(:contact)
       @account.contacts << @contact
       @opportunity = FactoryGirl.create(:opportunity)
       @account.opportunities << @opportunity
 
-      @account.attach!(@task).should == nil
-      @account.attach!(@contact).should == nil
-      @account.attach!(@opportunity).should == nil
+      expect(@account.attach!(@task)).to eq(nil)
+      expect(@account.attach!(@contact)).to eq(nil)
+      expect(@account.attach!(@opportunity)).to eq(nil)
     end
 
     it "should return non-empty list of attachments when attaching new asset" do
-      @task = FactoryGirl.create(:task, :user => current_user)
+      @task = FactoryGirl.create(:task, user: current_user)
       @contact = FactoryGirl.create(:contact)
       @opportunity = FactoryGirl.create(:opportunity)
 
-      @account.attach!(@task).should == [ @task ]
-      @account.attach!(@contact).should == [ @contact ]
-      @account.attach!(@opportunity).should == [ @opportunity ]
+      expect(@account.attach!(@task)).to eq([@task])
+      expect(@account.attach!(@contact)).to eq([@contact])
+      expect(@account.attach!(@opportunity)).to eq([@opportunity])
     end
   end
 
@@ -69,72 +68,66 @@ describe Account do
     end
 
     it "should discard a task" do
-      @task = FactoryGirl.create(:task, :asset => @account, :user => current_user)
-      @account.tasks.count.should == 1
+      @task = FactoryGirl.create(:task, asset: @account, user: current_user)
+      expect(@account.tasks.count).to eq(1)
 
       @account.discard!(@task)
-      @account.reload.tasks.should == []
-      @account.tasks.count.should == 0
+      expect(@account.reload.tasks).to eq([])
+      expect(@account.tasks.count).to eq(0)
     end
 
     it "should discard a contact" do
       @contact = FactoryGirl.create(:contact)
       @account.contacts << @contact
-      @account.contacts.count.should == 1
+      expect(@account.contacts.count).to eq(1)
 
       @account.discard!(@contact)
-      @account.contacts.should == []
-      @account.contacts.count.should == 0
+      expect(@account.contacts).to eq([])
+      expect(@account.contacts.count).to eq(0)
     end
 
-# Commented out this test. "super from singleton method that is defined to multiple classes is not supported;"
-# ------------------------------------------------------
-#    it "should discard an opportunity" do
-#      @opportunity = FactoryGirl.create(:opportunity)
-#      @account.opportunities << @opportunity
-#      @account.opportunities.count.should == 1
-
-#      @account.discard!(@opportunity)
-#      @account.opportunities.should == []
-#      @account.opportunities.count.should == 0
-#    end
+    # Commented out this test. "super from singleton method that is defined to multiple classes is not supported;"
+    # ------------------------------------------------------
+    #    it "should discard an opportunity" do
+    #      @opportunity = FactoryGirl.create(:opportunity)
+    #      @account.opportunities << @opportunity
+    #      @account.opportunities.count.should == 1
+
+    #      @account.discard!(@opportunity)
+    #      @account.opportunities.should == []
+    #      @account.opportunities.count.should == 0
+    #    end
   end
 
   describe "Exportable" do
     describe "assigned account" do
-      before do
-        Account.delete_all
-        FactoryGirl.create(:account, :user => FactoryGirl.create(:user), :assignee => FactoryGirl.create(:user))
-        FactoryGirl.create(:account, :user => FactoryGirl.create(:user, :first_name => nil, :last_name => nil), :assignee => FactoryGirl.create(:user, :first_name => nil, :last_name => nil))
-      end
+      let(:account1) { FactoryGirl.build(:account, user: FactoryGirl.create(:user), assignee: FactoryGirl.create(:user)) }
+      let(:account2) { FactoryGirl.build(:account, user: FactoryGirl.create(:user, first_name: nil, last_name: nil), assignee: FactoryGirl.create(:user, first_name: nil, last_name: nil)) }
       it_should_behave_like("exportable") do
-        let(:exported) { Account.all }
+        let(:exported) { [account1, account2] }
       end
     end
 
     describe "unassigned account" do
-      before do
-        Account.delete_all
-        FactoryGirl.create(:account, :user => FactoryGirl.create(:user), :assignee => nil)
-        FactoryGirl.create(:account, :user => FactoryGirl.create(:user, :first_name => nil, :last_name => nil), :assignee => nil)
-      end
+      let(:account1) { FactoryGirl.build(:account, user: FactoryGirl.create(:user), assignee: nil) }
+      let(:account2) { FactoryGirl.build(:account, user: FactoryGirl.create(:user, first_name: nil, last_name: nil), assignee: nil) }
       it_should_behave_like("exportable") do
-        let(:exported) { Account.all }
+        let(:exported) { [account1, account2] }
       end
     end
   end
 
   describe "Before save" do
     it "create new: should replace empty category string with nil" do
-      account = FactoryGirl.build(:account, :category => '')
+      account = FactoryGirl.build(:account, category: '')
       account.save
-      account.category.should == nil
+      expect(account.category).to eq(nil)
     end
 
     it "update existing: should replace empty category string with nil" do
-      account = FactoryGirl.create(:account, :category => '')
+      account = FactoryGirl.create(:account, category: '')
       account.save
-      account.category.should == nil
+      expect(account.category).to eq(nil)
     end
   end
 
@@ -146,39 +139,39 @@ describe Account do
     context "visible_on_dashboard" do
       before :each do
         @user = FactoryGirl.create(:user)
-        @a1 = FactoryGirl.create(:account, :user => @user)
-        @a2 = FactoryGirl.create(:account, :user => @user, :assignee => FactoryGirl.create(:user))
-        @a3 = FactoryGirl.create(:account, :user => FactoryGirl.create(:user), :assignee => @user)
-        @a4 = FactoryGirl.create(:account, :user => FactoryGirl.create(:user), :assignee => FactoryGirl.create(:user))
-        @a5 = FactoryGirl.create(:account, :user => FactoryGirl.create(:user), :assignee => @user)
+        @a1 = FactoryGirl.create(:account, user: @user)
+        @a2 = FactoryGirl.create(:account, user: @user, assignee: FactoryGirl.create(:user))
+        @a3 = FactoryGirl.create(:account, user: FactoryGirl.create(:user), assignee: @user)
+        @a4 = FactoryGirl.create(:account, user: FactoryGirl.create(:user), assignee: FactoryGirl.create(:user))
+        @a5 = FactoryGirl.create(:account, user: FactoryGirl.create(:user), assignee: @user)
       end
 
       it "should show accounts which have been created by the user and are unassigned" do
-        Account.visible_on_dashboard(@user).should include(@a1)
+        expect(Account.visible_on_dashboard(@user)).to include(@a1)
       end
 
       it "should show accounts which are assigned to the user" do
-        Account.visible_on_dashboard(@user).should include(@a3, @a5)
+        expect(Account.visible_on_dashboard(@user)).to include(@a3, @a5)
       end
 
       it "should not show accounts which are not assigned to the user" do
-        Account.visible_on_dashboard(@user).should_not include(@a4)
+        expect(Account.visible_on_dashboard(@user)).not_to include(@a4)
       end
 
       it "should not show accounts which are created by the user but assigned" do
-        Account.visible_on_dashboard(@user).should_not include(@a2)
+        expect(Account.visible_on_dashboard(@user)).not_to include(@a2)
       end
     end
 
     context "by_name" do
       it "should show accounts ordered by name" do
-        @a1 = FactoryGirl.create(:account, :name => "Account A")
-        @a2 = FactoryGirl.create(:account, :name => "Account Z")
-        @a3 = FactoryGirl.create(:account, :name => "Account J")
-        @a4 = FactoryGirl.create(:account, :name => "Account X")
-        @a5 = FactoryGirl.create(:account, :name => "Account L")
+        @a1 = FactoryGirl.create(:account, name: "Account A")
+        @a2 = FactoryGirl.create(:account, name: "Account Z")
+        @a3 = FactoryGirl.create(:account, name: "Account J")
+        @a4 = FactoryGirl.create(:account, name: "Account X")
+        @a5 = FactoryGirl.create(:account, name: "Account L")
 
-        Account.by_name.should == [@a1, @a3, @a5, @a4, @a2]
+        expect(Account.by_name).to eq([@a1, @a3, @a5, @a4, @a2])
       end
     end
   end

data/spec/models/entities/campaign_spec.rb

@@ -32,11 +32,10 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Campaign do
-
   before { login }
 
   it "should create a new instance given valid attributes" do
-    Campaign.create!(:name => "Campaign", :user => FactoryGirl.create(:user))
+    Campaign.create!(name: "Campaign", user: FactoryGirl.create(:user))
   end
 
   describe "Attach" do
@@ -45,23 +44,23 @@ describe Campaign do
     end
 
     it "should return nil when attaching existing asset" do
-      @task = FactoryGirl.create(:task, :asset => @campaign, :user => current_user)
-      @lead = FactoryGirl.create(:lead, :campaign => @campaign)
-      @opportunity = FactoryGirl.create(:opportunity, :campaign => @campaign)
+      @task = FactoryGirl.create(:task, asset: @campaign, user: current_user)
+      @lead = FactoryGirl.create(:lead, campaign: @campaign)
+      @opportunity = FactoryGirl.create(:opportunity, campaign: @campaign)
 
-      @campaign.attach!(@task).should == nil
-      @campaign.attach!(@lead).should == nil
-      @campaign.attach!(@opportunity).should == nil
+      expect(@campaign.attach!(@task)).to eq(nil)
+      expect(@campaign.attach!(@lead)).to eq(nil)
+      expect(@campaign.attach!(@opportunity)).to eq(nil)
     end
 
     it "should return non-empty list of attachments when attaching new asset" do
-      @task = FactoryGirl.create(:task, :user => current_user)
+      @task = FactoryGirl.create(:task, user: current_user)
       @lead = FactoryGirl.create(:lead)
       @opportunity = FactoryGirl.create(:opportunity)
 
-      @campaign.attach!(@task).should == [ @task ]
-      @campaign.attach!(@lead).should == [ @lead ]
-      @campaign.attach!(@opportunity).should == [ @opportunity ]
+      expect(@campaign.attach!(@task)).to eq([@task])
+      expect(@campaign.attach!(@lead)).to eq([@lead])
+      expect(@campaign.attach!(@opportunity)).to eq([@opportunity])
     end
 
     it "should increment leads count when attaching a new lead" do
@@ -69,70 +68,64 @@ describe Campaign do
       @lead = FactoryGirl.create(:lead)
 
       @campaign.attach!(@lead)
-      @campaign.reload.leads_count.should == @leads_count + 1
+      expect(@campaign.reload.leads_count).to eq(@leads_count + 1)
     end
 
     it "should increment opportunities count when attaching new opportunity" do
       @opportunities_count = @campaign.opportunities_count
       @opportunity = FactoryGirl.create(:opportunity)
       @campaign.attach!(@opportunity)
-      @campaign.reload.opportunities_count.should == @opportunities_count + 1
+      expect(@campaign.reload.opportunities_count).to eq(@opportunities_count + 1)
     end
   end
 
   describe "Detach" do
     before do
-      @campaign = FactoryGirl.create(:campaign, :leads_count => 42, :opportunities_count => 42)
+      @campaign = FactoryGirl.create(:campaign, leads_count: 42, opportunities_count: 42)
     end
 
     it "should discard a task" do
-      @task = FactoryGirl.create(:task, :asset => @campaign, :user => current_user)
-      @campaign.tasks.count.should == 1
+      @task = FactoryGirl.create(:task, asset: @campaign, user: current_user)
+      expect(@campaign.tasks.count).to eq(1)
 
       @campaign.discard!(@task)
-      @campaign.reload.tasks.should == []
-      @campaign.tasks.count.should == 0
+      expect(@campaign.reload.tasks).to eq([])
+      expect(@campaign.tasks.count).to eq(0)
     end
 
     it "should discard a lead" do
-      @lead = FactoryGirl.create(:lead, :campaign => @campaign)
-      @campaign.reload.leads_count.should == 43
+      @lead = FactoryGirl.create(:lead, campaign: @campaign)
+      expect(@campaign.reload.leads_count).to eq(43)
 
       @campaign.discard!(@lead)
-      @campaign.leads.should == []
-      @campaign.reload.leads_count.should == 42
+      expect(@campaign.leads).to eq([])
+      expect(@campaign.reload.leads_count).to eq(42)
     end
 
     it "should discard an opportunity" do
-      @opportunity = FactoryGirl.create(:opportunity, :campaign => @campaign)
-      @campaign.reload.opportunities_count.should == 43
+      @opportunity = FactoryGirl.create(:opportunity, campaign: @campaign)
+      expect(@campaign.reload.opportunities_count).to eq(43)
 
       @campaign.discard!(@opportunity)
-      @campaign.opportunities.should == []
-      @campaign.reload.opportunities_count.should == 42
+      expect(@campaign.opportunities).to eq([])
+      expect(@campaign.reload.opportunities_count).to eq(42)
     end
   end
 
   describe "Exportable" do
     describe "assigned campaign" do
-      before do
-        Campaign.delete_all
-        FactoryGirl.create(:campaign, :user => FactoryGirl.create(:user, :first_name => "John", :last_name => "Smith"), :assignee => FactoryGirl.create(:user))
-        FactoryGirl.create(:campaign, :user => FactoryGirl.create(:user, :first_name => nil, :last_name => nil), :assignee => FactoryGirl.create(:user, :first_name => nil, :last_name => nil))
-      end
+      let(:campaign1) { FactoryGirl.build(:campaign, user: FactoryGirl.create(:user, first_name: "John", last_name: "Smith"), assignee: FactoryGirl.create(:user)) }
+      let(:campaign2) { FactoryGirl.build(:campaign, user: FactoryGirl.create(:user, first_name: nil, last_name: nil), assignee: FactoryGirl.create(:user, first_name: nil, last_name: nil)) }
       it_should_behave_like("exportable") do
-        let(:exported) { Campaign.all }
+        let(:exported) { [campaign1, campaign2] }
       end
     end
 
     describe "unassigned campaign" do
-      before do
-        Campaign.delete_all
-        FactoryGirl.create(:campaign, :user => FactoryGirl.create(:user), :assignee => nil)
-        FactoryGirl.create(:campaign, :user => FactoryGirl.create(:user, :first_name => nil, :last_name => nil), :assignee => nil)
-      end
+      let(:campaign1) { FactoryGirl.build(:campaign, user: FactoryGirl.create(:user), assignee: nil) }
+      let(:campaign2) { FactoryGirl.build(:campaign, user: FactoryGirl.create(:user, first_name: nil, last_name: nil), assignee: nil) }
       it_should_behave_like("exportable") do
-        let(:exported) { Campaign.all }
+        let(:exported) { [campaign1, campaign2] }
       end
     end
   end