fat_free_crm 0.13.6 → 0.14.0

data/spec/models/entities/contact_opportunity_spec.rb

@@ -21,8 +21,8 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 describe ContactOpportunity do
   before(:each) do
     @valid_attributes = {
-      :contact => mock_model(Contact),
-      :opportunity => mock_model(Opportunity)
+      contact: mock_model(Contact),
+      opportunity: mock_model(Opportunity)
     }
   end
 
@@ -30,4 +30,3 @@ describe ContactOpportunity do
     ContactOpportunity.create!(@valid_attributes)
   end
 end
-

data/spec/models/entities/contact_spec.rb

@@ -39,54 +39,61 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Contact do
-
   before { login }
 
   it "should create a new instance given valid attributes" do
-    Contact.create!(:first_name => "Billy", :last_name => "Bones")
+    Contact.create!(first_name: "Billy", last_name: "Bones")
   end
 
   describe "Update existing contact" do
     before(:each) do
       @account = FactoryGirl.create(:account)
-      @contact = FactoryGirl.create(:contact, :account => @account)
+      @contact = FactoryGirl.create(:contact, account: @account)
     end
 
     it "should create new account if requested so" do
-      lambda { @contact.update_with_account_and_permissions({
-        :account => { :name => "New account" },
-        :contact => { :first_name => "Billy" }
-      })}.should change(Account, :count).by(1)
-      Account.last.name.should == "New account"
-      @contact.first_name.should == "Billy"
+      expect {
+        @contact.update_with_account_and_permissions(
+        account: { name: "New account" },
+        contact: { first_name: "Billy" }
+      )
+      }.to change(Account, :count).by(1)
+      expect(Account.last.name).to eq("New account")
+      expect(@contact.first_name).to eq("Billy")
     end
 
     it "should change account if another account was selected" do
       @another_account = FactoryGirl.create(:account)
-      lambda { @contact.update_with_account_and_permissions({
-        :account => { :id => @another_account.id },
-        :contact => { :first_name => "Billy" }
-      })}.should_not change(Account, :count)
-      @contact.account.should == @another_account
-      @contact.first_name.should == "Billy"
+      expect {
+        @contact.update_with_account_and_permissions(
+        account: { id: @another_account.id },
+        contact: { first_name: "Billy" }
+      )
+      }.not_to change(Account, :count)
+      expect(@contact.account).to eq(@another_account)
+      expect(@contact.first_name).to eq("Billy")
     end
 
     it "should drop existing Account if [create new account] is blank" do
-      lambda { @contact.update_with_account_and_permissions({
-        :account => { :name => "" },
-        :contact => { :first_name => "Billy" }
-      })}.should_not change(Account, :count)
-      @contact.account.should == nil
-      @contact.first_name.should == "Billy"
+      expect {
+        @contact.update_with_account_and_permissions(
+        account: { name: "" },
+        contact: { first_name: "Billy" }
+      )
+      }.not_to change(Account, :count)
+      expect(@contact.account).to eq(nil)
+      expect(@contact.first_name).to eq("Billy")
     end
 
     it "should drop existing Account if [-- None --] is selected from list of accounts" do
-      lambda { @contact.update_with_account_and_permissions({
-        :account => { :id => "" },
-        :contact => { :first_name => "Billy" }
-      })}.should_not change(Account, :count)
-      @contact.account.should == nil
-      @contact.first_name.should == "Billy"
+      expect {
+        @contact.update_with_account_and_permissions(
+        account: { id: "" },
+        contact: { first_name: "Billy" }
+      )
+      }.not_to change(Account, :count)
+      expect(@contact.account).to eq(nil)
+      expect(@contact.first_name).to eq("Billy")
     end
   end
 
@@ -96,20 +103,20 @@ describe Contact do
     end
 
     it "should return nil when attaching existing asset" do
-      @task = FactoryGirl.create(:task, :asset => @contact, :user => current_user)
+      @task = FactoryGirl.create(:task, asset: @contact, user: current_user)
       @opportunity = FactoryGirl.create(:opportunity)
       @contact.opportunities << @opportunity
 
-      @contact.attach!(@task).should == nil
-      @contact.attach!(@opportunity).should == nil
+      expect(@contact.attach!(@task)).to eq(nil)
+      expect(@contact.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)
       @opportunity = FactoryGirl.create(:opportunity)
 
-      @contact.attach!(@task).should == [ @task ]
-      @contact.attach!(@opportunity).should == [ @opportunity ]
+      expect(@contact.attach!(@task)).to eq([@task])
+      expect(@contact.attach!(@opportunity)).to eq([@opportunity])
     end
   end
 
@@ -119,91 +126,83 @@ describe Contact do
     end
 
     it "should discard a task" do
-      @task = FactoryGirl.create(:task, :asset => @contact, :user => current_user)
-      @contact.tasks.count.should == 1
+      @task = FactoryGirl.create(:task, asset: @contact, user: current_user)
+      expect(@contact.tasks.count).to eq(1)
 
       @contact.discard!(@task)
-      @contact.reload.tasks.should == []
-      @contact.tasks.count.should == 0
+      expect(@contact.reload.tasks).to eq([])
+      expect(@contact.tasks.count).to eq(0)
     end
 
     it "should discard an opportunity" do
       @opportunity = FactoryGirl.create(:opportunity)
       @contact.opportunities << @opportunity
-      @contact.opportunities.count.should == 1
+      expect(@contact.opportunities.count).to eq(1)
 
       @contact.discard!(@opportunity)
-      @contact.opportunities.should == []
-      @contact.opportunities.count.should == 0
+      expect(@contact.opportunities).to eq([])
+      expect(@contact.opportunities.count).to eq(0)
     end
   end
 
   describe "Exportable" do
     describe "assigned contact" do
-      before do
-        Contact.delete_all
-        FactoryGirl.create(:contact, :user => FactoryGirl.create(:user), :assignee => FactoryGirl.create(:user))
-        FactoryGirl.create(:contact, :user => FactoryGirl.create(:user, :first_name => nil, :last_name => nil), :assignee => FactoryGirl.create(:user, :first_name => nil, :last_name => nil))
-      end
+      let(:contact1) { FactoryGirl.build(:contact, user: FactoryGirl.create(:user), assignee: FactoryGirl.create(:user)) }
+      let(:contact2) { FactoryGirl.build(:contact, 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) { Contact.all }
+        let(:exported) { [contact1, contact2] }
       end
     end
 
     describe "unassigned contact" do
-      before do
-        Contact.delete_all
-        FactoryGirl.create(:contact, :user => FactoryGirl.create(:user), :assignee => nil)
-        FactoryGirl.create(:contact, :user => FactoryGirl.create(:user, :first_name => nil, :last_name => nil), :assignee => nil)
-      end
+      let(:contact1) { FactoryGirl.build(:contact, user: FactoryGirl.create(:user), assignee: nil) }
+      let(:contact2) { FactoryGirl.build(:contact, user: FactoryGirl.create(:user, first_name: nil, last_name: nil), assignee: nil) }
       it_should_behave_like("exportable") do
-        let(:exported) { Contact.all }
+        let(:exported) { [contact1, contact2] }
       end
     end
   end
-  
+
   describe "permissions" do
     it_should_behave_like Ability, Contact
   end
-  
+
   describe "text_search" do
-  
     before(:each) do
-      @contact = FactoryGirl.create(:contact, :first_name => "Bob", :last_name => "Dillion", :email => 'bob_dillion@example.com', :phone => '+1 123 456 789')
+      @contact = FactoryGirl.create(:contact, first_name: "Bob", last_name: "Dillion", email: 'bob_dillion@example.com', phone: '+1 123 456 789')
     end
-    
+
     it "should search first_name" do
-      Contact.text_search('Bob').should == [@contact]
+      expect(Contact.text_search('Bob')).to eq([@contact])
     end
 
     it "should search last_name" do
-      Contact.text_search('Dillion').should == [@contact]
+      expect(Contact.text_search('Dillion')).to eq([@contact])
     end
-    
+
     it "should search whole name" do
-      Contact.text_search('Bob Dillion').should == [@contact]
+      expect(Contact.text_search('Bob Dillion')).to eq([@contact])
     end
-    
+
     it "should search whole name reversed" do
-      Contact.text_search('Dillion Bob').should == [@contact]
+      expect(Contact.text_search('Dillion Bob')).to eq([@contact])
     end
 
     it "should search email" do
-      Contact.text_search('example').should == [@contact]
+      expect(Contact.text_search('example')).to eq([@contact])
     end
-    
+
     it "should search phone" do
-      Contact.text_search('123').should == [@contact]
+      expect(Contact.text_search('123')).to eq([@contact])
     end
-    
+
     it "should not break with a single quote" do
-      contact2 = FactoryGirl.create(:contact, :first_name => "Shamus", :last_name => "O'Connell", :email => 'bob_dillion@example.com', :phone => '+1 123 456 789')
-      Contact.text_search("O'Connell").should == [contact2]
+      contact2 = FactoryGirl.create(:contact, first_name: "Shamus", last_name: "O'Connell", email: 'bob_dillion@example.com', phone: '+1 123 456 789')
+      expect(Contact.text_search("O'Connell")).to eq([contact2])
     end
-    
+
     it "should not break on special characters" do
-      Contact.text_search('@$%#^@!').should == []
+      expect(Contact.text_search('@$%#^@!')).to eq([])
     end
-  
   end
 end

data/spec/models/entities/lead_spec.rb

@@ -39,11 +39,10 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Lead do
-
   before { login }
 
   it "should create a new instance given valid attributes" do
-    Lead.create!(:first_name => "Billy", :last_name => "Bones")
+    Lead.create!(first_name: "Billy", last_name: "Bones")
   end
 
   describe "Attach" do
@@ -52,15 +51,15 @@ describe Lead do
     end
 
     it "should return nil when attaching existing task" do
-      @task = FactoryGirl.create(:task, :asset => @lead, :user => current_user)
+      @task = FactoryGirl.create(:task, asset: @lead, user: current_user)
 
-      @lead.attach!(@task).should == nil
+      expect(@lead.attach!(@task)).to eq(nil)
     end
 
     it "should return non-empty list of tasks when attaching new task" do
-      @task = FactoryGirl.create(:task, :user => current_user)
+      @task = FactoryGirl.create(:task, user: current_user)
 
-      @lead.attach!(@task).should == [ @task ]
+      expect(@lead.attach!(@task)).to eq([@task])
     end
   end
 
@@ -70,35 +69,29 @@ describe Lead do
     end
 
     it "should discard a task" do
-      @task = FactoryGirl.create(:task, :asset => @lead, :user => current_user)
-      @lead.tasks.count.should == 1
+      @task = FactoryGirl.create(:task, asset: @lead, user: current_user)
+      expect(@lead.tasks.count).to eq(1)
 
       @lead.discard!(@task)
-      @lead.reload.tasks.should == []
-      @lead.tasks.count.should == 0
+      expect(@lead.reload.tasks).to eq([])
+      expect(@lead.tasks.count).to eq(0)
     end
   end
 
   describe "Exportable" do
     describe "assigned lead" do
-      before do
-        Lead.delete_all
-        FactoryGirl.create(:lead, :user => FactoryGirl.create(:user), :assignee => FactoryGirl.create(:user))
-        FactoryGirl.create(:lead, :user => FactoryGirl.create(:user, :first_name => nil, :last_name => nil), :assignee => FactoryGirl.create(:user, :first_name => nil, :last_name => nil))
-      end
+      let(:lead1) { FactoryGirl.build(:lead, user: FactoryGirl.create(:user), assignee: FactoryGirl.create(:user)) }
+      let(:lead2) { FactoryGirl.build(:lead, 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) { Lead.all }
+        let(:exported) { [lead1, lead2] }
       end
     end
 
     describe "unassigned lead" do
-      before do
-        Lead.delete_all
-        FactoryGirl.create(:lead, :user => FactoryGirl.create(:user), :assignee => nil)
-        FactoryGirl.create(:lead, :user => FactoryGirl.create(:user, :first_name => nil, :last_name => nil), :assignee => nil)
-      end
+      let(:lead1) { FactoryGirl.build(:lead, user: FactoryGirl.create(:user), assignee: nil) }
+      let(:lead2) { FactoryGirl.build(:lead, user: FactoryGirl.create(:user, first_name: nil, last_name: nil), assignee: nil) }
       it_should_behave_like("exportable") do
-        let(:exported) { Lead.all }
+        let(:exported) { [lead1, lead2] }
       end
     end
   end

data/spec/models/entities/opportunity_spec.rb

@@ -28,82 +28,89 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Opportunity do
-
   before { login }
 
   it "should create a new instance given valid attributes" do
-    Opportunity.create!(:name => "Opportunity", :stage => 'analysis')
+    Opportunity.create!(name: "Opportunity", stage: 'analysis')
   end
 
   it "should be possible to create opportunity with the same name" do
-    first  = FactoryGirl.create(:opportunity, :name => "Hello", :user => current_user)
-    expect { FactoryGirl.create(:opportunity, :name => "Hello", :user => current_user) }.to_not raise_error()
+    first  = FactoryGirl.create(:opportunity, name: "Hello", user: current_user)
+    expect { FactoryGirl.create(:opportunity, name: "Hello", user: current_user) }.to_not raise_error
   end
 
   it "have a default stage" do
-    Setting.should_receive(:[]).with(:opportunity_default_stage).and_return('default')
-    Opportunity.default_stage.should eql('default')
+    expect(Setting).to receive(:[]).with(:opportunity_default_stage).and_return('default')
+    expect(Opportunity.default_stage).to eql('default')
   end
 
   it "have a fallback default stage" do
-    Opportunity.default_stage.should eql('prospecting')
+    expect(Opportunity.default_stage).to eql('prospecting')
   end
 
   describe "Update existing opportunity" do
     before(:each) do
       @account = FactoryGirl.create(:account)
-      @opportunity = FactoryGirl.create(:opportunity, :account => @account)
+      @opportunity = FactoryGirl.create(:opportunity, account: @account)
     end
 
     it "should create new account if requested so" do
-      lambda { @opportunity.update_with_account_and_permissions({
-        :account => { :name => "New account" },
-        :opportunity => { :name => "Hello" }
-      })}.should change(Account, :count).by(1)
-      Account.last.name.should == "New account"
-      @opportunity.name.gsub(/#\d+ /,'').should == "Hello"
+      expect {
+        @opportunity.update_with_account_and_permissions(
+        account: { name: "New account" },
+        opportunity: { name: "Hello" }
+      )
+      }.to change(Account, :count).by(1)
+      expect(Account.last.name).to eq("New account")
+      expect(@opportunity.name.gsub(/#\d+ /, '')).to eq("Hello")
     end
 
     it "should update the account another account was selected" do
       @another_account = FactoryGirl.create(:account)
-      lambda { @opportunity.update_with_account_and_permissions({
-        :account => { :id => @another_account.id },
-        :opportunity => { :name => "Hello" }
-      })}.should_not change(Account, :count)
-      @opportunity.account.should == @another_account
-      @opportunity.name.gsub(/#\d+ /,'').should == "Hello"
+      expect {
+        @opportunity.update_with_account_and_permissions(
+        account: { id: @another_account.id },
+        opportunity: { name: "Hello" }
+      )
+      }.not_to change(Account, :count)
+      expect(@opportunity.account).to eq(@another_account)
+      expect(@opportunity.name.gsub(/#\d+ /, '')).to eq("Hello")
     end
 
     it "should drop existing Account if [create new account] is blank" do
-      lambda { @opportunity.update_with_account_and_permissions({
-        :account => { :name => "" },
-        :opportunity => { :name => "Hello" }
-      })}.should_not change(Account, :count)
-      @opportunity.account.should be_nil
-      @opportunity.name.gsub(/#\d+ /,'').should == "Hello"
+      expect {
+        @opportunity.update_with_account_and_permissions(
+        account: { name: "" },
+        opportunity: { name: "Hello" }
+      )
+      }.not_to change(Account, :count)
+      expect(@opportunity.account).to be_nil
+      expect(@opportunity.name.gsub(/#\d+ /, '')).to eq("Hello")
     end
 
     it "should drop existing Account if [-- None --] is selected from list of accounts" do
-      lambda { @opportunity.update_with_account_and_permissions({
-        :account => { :id => "" },
-        :opportunity => { :name => "Hello" }
-      })}.should_not change(Account, :count)
-      @opportunity.account.should be_nil
-      @opportunity.name.gsub(/#\d+ /,'').should == "Hello"
+      expect {
+        @opportunity.update_with_account_and_permissions(
+        account: { id: "" },
+        opportunity: { name: "Hello" }
+      )
+      }.not_to change(Account, :count)
+      expect(@opportunity.account).to be_nil
+      expect(@opportunity.name.gsub(/#\d+ /, '')).to eq("Hello")
     end
 
     it "should set the probability to 0% if opportunity has been lost" do
-      opportunity = FactoryGirl.create(:opportunity, :stage => "prospecting", :probability => 25)
-      opportunity.update_attributes(:stage => 'lost')
+      opportunity = FactoryGirl.create(:opportunity, stage: "prospecting", probability: 25)
+      opportunity.update_attributes(stage: 'lost')
       opportunity.reload
-      opportunity.probability.should == 0
+      expect(opportunity.probability).to eq(0)
     end
 
     it "should set the probablility to 100% if opportunity has been won" do
-      opportunity = FactoryGirl.create(:opportunity, :stage => "prospecting", :probability => 65)
-      opportunity.update_attributes(:stage => 'won')
+      opportunity = FactoryGirl.create(:opportunity, stage: "prospecting", probability: 65)
+      opportunity.update_attributes(stage: 'won')
       opportunity.reload
-      opportunity.probability.should == 100
+      expect(opportunity.probability).to eq(100)
     end
   end
 
@@ -111,29 +118,29 @@ describe Opportunity do
     it "should find non-closed opportunities" do
       Opportunity.delete_all
       @opportunities = [
-        FactoryGirl.create(:opportunity, :stage => "prospecting", :amount => 1),
-        FactoryGirl.create(:opportunity, :stage => "analysis", :amount => 1),
-        FactoryGirl.create(:opportunity, :stage => "won",      :amount => 2),
-        FactoryGirl.create(:opportunity, :stage => "won",      :amount => 2),
-        FactoryGirl.create(:opportunity, :stage => "lost",     :amount => 3),
-        FactoryGirl.create(:opportunity, :stage => "lost",     :amount => 3)
+        FactoryGirl.create(:opportunity, stage: "prospecting", amount: 1),
+        FactoryGirl.create(:opportunity, stage: "analysis", amount: 1),
+        FactoryGirl.create(:opportunity, stage: "won",      amount: 2),
+        FactoryGirl.create(:opportunity, stage: "won",      amount: 2),
+        FactoryGirl.create(:opportunity, stage: "lost",     amount: 3),
+        FactoryGirl.create(:opportunity, stage: "lost",     amount: 3)
       ]
-      Opportunity.pipeline.sum(:amount).should ==  2
-      Opportunity.won.sum(:amount).should      ==  4
-      Opportunity.lost.sum(:amount).should     ==  6
-      Opportunity.sum(:amount).should          == 12
+      expect(Opportunity.pipeline.sum(:amount)).to eq(2)
+      expect(Opportunity.won.sum(:amount)).to eq(4)
+      expect(Opportunity.lost.sum(:amount)).to eq(6)
+      expect(Opportunity.sum(:amount)).to eq(12)
     end
 
     context "unassigned" do
-      let(:unassigned_opportunity){ FactoryGirl.create(:opportunity, :assignee => nil)}
-      let(:assigned_opportunity){ FactoryGirl.create(:opportunity, :assignee => FactoryGirl.create(:user))}
+      let(:unassigned_opportunity) { FactoryGirl.create(:opportunity, assignee: nil) }
+      let(:assigned_opportunity) { FactoryGirl.create(:opportunity, assignee: FactoryGirl.create(:user)) }
 
       it "includes unassigned opportunities" do
-        Opportunity.unassigned.should include(unassigned_opportunity)
+        expect(Opportunity.unassigned).to include(unassigned_opportunity)
       end
 
       it "does not include opportunities assigned to a user" do
-        Opportunity.unassigned.should_not include(assigned_opportunity)
+        expect(Opportunity.unassigned).not_to include(assigned_opportunity)
       end
     end
   end
@@ -144,20 +151,20 @@ describe Opportunity do
     end
 
     it "should return nil when attaching existing asset" do
-      @task = FactoryGirl.create(:task, :asset => @opportunity, :user => current_user)
+      @task = FactoryGirl.create(:task, asset: @opportunity, user: current_user)
       @contact = FactoryGirl.create(:contact)
       @opportunity.contacts << @contact
 
-      @opportunity.attach!(@task).should == nil
-      @opportunity.attach!(@contact).should == nil
+      expect(@opportunity.attach!(@task)).to eq(nil)
+      expect(@opportunity.attach!(@contact)).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.attach!(@task).should == [ @task ]
-      @opportunity.attach!(@contact).should == [ @contact ]
+      expect(@opportunity.attach!(@task)).to eq([@task])
+      expect(@opportunity.attach!(@contact)).to eq([@contact])
     end
   end
 
@@ -167,45 +174,39 @@ describe Opportunity do
     end
 
     it "should discard a task" do
-      @task = FactoryGirl.create(:task, :asset => @opportunity, :user => current_user)
-      @opportunity.tasks.count.should == 1
+      @task = FactoryGirl.create(:task, asset: @opportunity, user: current_user)
+      expect(@opportunity.tasks.count).to eq(1)
 
       @opportunity.discard!(@task)
-      @opportunity.reload.tasks.should == []
-      @opportunity.tasks.count.should == 0
+      expect(@opportunity.reload.tasks).to eq([])
+      expect(@opportunity.tasks.count).to eq(0)
     end
 
     it "should discard an contact" do
       @contact = FactoryGirl.create(:contact)
       @opportunity.contacts << @contact
-      @opportunity.contacts.count.should == 1
+      expect(@opportunity.contacts.count).to eq(1)
 
       @opportunity.discard!(@contact)
-      @opportunity.contacts.should == []
-      @opportunity.contacts.count.should == 0
+      expect(@opportunity.contacts).to eq([])
+      expect(@opportunity.contacts.count).to eq(0)
     end
   end
 
   describe "Exportable" do
     describe "assigned opportunity" do
-      before do
-        Opportunity.delete_all
-        FactoryGirl.create(:opportunity, :user => FactoryGirl.create(:user), :assignee => FactoryGirl.create(:user))
-        FactoryGirl.create(:opportunity, :user => FactoryGirl.create(:user, :first_name => nil, :last_name => nil), :assignee => FactoryGirl.create(:user, :first_name => nil, :last_name => nil))
-      end
+      let(:opportunity1) { FactoryGirl.build(:opportunity, user: FactoryGirl.create(:user), assignee: FactoryGirl.create(:user)) }
+      let(:opportunity2) { FactoryGirl.build(:opportunity, 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) { Opportunity.all }
+        let(:exported) { [opportunity1, opportunity2] }
       end
     end
 
     describe "unassigned opportunity" do
-      before do
-        Opportunity.delete_all
-        FactoryGirl.create(:opportunity, :user => FactoryGirl.create(:user), :assignee => nil)
-        FactoryGirl.create(:opportunity, :user => FactoryGirl.create(:user, :first_name => nil, :last_name => nil), :assignee => nil)
-      end
+      let(:opportunity1) { FactoryGirl.build(:opportunity, user: FactoryGirl.create(:user), assignee: nil) }
+      let(:opportunity2) { FactoryGirl.build(:opportunity, user: FactoryGirl.create(:user, first_name: nil, last_name: nil), assignee: nil) }
       it_should_behave_like("exportable") do
-        let(:exported) { Opportunity.all }
+        let(:exported) { [opportunity1, opportunity2] }
       end
     end
   end
@@ -218,68 +219,68 @@ describe Opportunity do
     context "visible_on_dashboard" do
       before :each do
         @user = FactoryGirl.create(:user)
-        @o1 = FactoryGirl.create(:opportunity_in_pipeline, :user => @user, :stage => 'prospecting')
-        @o2 = FactoryGirl.create(:opportunity_in_pipeline, :user => @user, :assignee => FactoryGirl.create(:user), :stage => 'prospecting')
-        @o3 = FactoryGirl.create(:opportunity_in_pipeline, :user => FactoryGirl.create(:user), :assignee => @user, :stage => 'prospecting')
-        @o4 = FactoryGirl.create(:opportunity_in_pipeline, :user => FactoryGirl.create(:user), :assignee => FactoryGirl.create(:user), :stage => 'prospecting')
-        @o5 = FactoryGirl.create(:opportunity_in_pipeline, :user => FactoryGirl.create(:user), :assignee => @user, :stage => 'prospecting')
-        @o6 = FactoryGirl.create(:opportunity, :assignee => @user, :stage => 'won')
-        @o7 = FactoryGirl.create(:opportunity, :assignee => @user, :stage => 'lost')
+        @o1 = FactoryGirl.create(:opportunity_in_pipeline, user: @user, stage: 'prospecting')
+        @o2 = FactoryGirl.create(:opportunity_in_pipeline, user: @user, assignee: FactoryGirl.create(:user), stage: 'prospecting')
+        @o3 = FactoryGirl.create(:opportunity_in_pipeline, user: FactoryGirl.create(:user), assignee: @user, stage: 'prospecting')
+        @o4 = FactoryGirl.create(:opportunity_in_pipeline, user: FactoryGirl.create(:user), assignee: FactoryGirl.create(:user), stage: 'prospecting')
+        @o5 = FactoryGirl.create(:opportunity_in_pipeline, user: FactoryGirl.create(:user), assignee: @user, stage: 'prospecting')
+        @o6 = FactoryGirl.create(:opportunity, assignee: @user, stage: 'won')
+        @o7 = FactoryGirl.create(:opportunity, assignee: @user, stage: 'lost')
       end
 
       it "should show opportunities which have been created by the user and are unassigned" do
-        Opportunity.visible_on_dashboard(@user).should include(@o1)
+        expect(Opportunity.visible_on_dashboard(@user)).to include(@o1)
       end
 
       it "should show opportunities which are assigned to the user" do
-        Opportunity.visible_on_dashboard(@user).should include(@o3, @o5)
+        expect(Opportunity.visible_on_dashboard(@user)).to include(@o3, @o5)
       end
 
       it "should not show opportunities which are not assigned to the user" do
-        Opportunity.visible_on_dashboard(@user).should_not include(@o4)
+        expect(Opportunity.visible_on_dashboard(@user)).not_to include(@o4)
       end
 
       it "should not show opportunities which are created by the user but assigned" do
-        Opportunity.visible_on_dashboard(@user).should_not include(@o2)
+        expect(Opportunity.visible_on_dashboard(@user)).not_to include(@o2)
       end
 
       it "does not include won or lost opportunities" do
-        Opportunity.visible_on_dashboard(@user).should_not include(@o6)
-        Opportunity.visible_on_dashboard(@user).should_not include(@o7)
+        expect(Opportunity.visible_on_dashboard(@user)).not_to include(@o6)
+        expect(Opportunity.visible_on_dashboard(@user)).not_to include(@o7)
       end
     end
 
     context "by_closes_on" do
-      let(:o1) { FactoryGirl.create(:opportunity, :closes_on => 3.days.from_now) }
-      let(:o2) { FactoryGirl.create(:opportunity, :closes_on => 7.days.from_now) }
-      let(:o3) { FactoryGirl.create(:opportunity, :closes_on => 5.days.from_now) }
+      let(:o1) { FactoryGirl.create(:opportunity, closes_on: 3.days.from_now) }
+      let(:o2) { FactoryGirl.create(:opportunity, closes_on: 7.days.from_now) }
+      let(:o3) { FactoryGirl.create(:opportunity, closes_on: 5.days.from_now) }
 
       it "should show opportunities ordered by closes on" do
-        Opportunity.by_closes_on.should == [o1, o3, o2]
+        expect(Opportunity.by_closes_on).to eq([o1, o3, o2])
       end
     end
 
     context "by_amount" do
-      let(:o1) { FactoryGirl.create(:opportunity, :amount =>  50000) }
-      let(:o2) { FactoryGirl.create(:opportunity, :amount =>  10000) }
-      let(:o3) { FactoryGirl.create(:opportunity, :amount => 750000) }
+      let(:o1) { FactoryGirl.create(:opportunity, amount:  50_000) }
+      let(:o2) { FactoryGirl.create(:opportunity, amount:  10_000) }
+      let(:o3) { FactoryGirl.create(:opportunity, amount: 750_000) }
 
       it "should show opportunities ordered by amount" do
-        Opportunity.by_amount.should == [o3, o1, o2]
+        expect(Opportunity.by_amount).to eq([o3, o1, o2])
       end
     end
 
     context "not lost" do
-      let(:o1) { FactoryGirl.create(:opportunity, :stage => 'won') }
-      let(:o2) { FactoryGirl.create(:opportunity, :stage => 'lost') }
-      let(:o3) { FactoryGirl.create(:opportunity, :stage => 'analysis') }
+      let(:o1) { FactoryGirl.create(:opportunity, stage: 'won') }
+      let(:o2) { FactoryGirl.create(:opportunity, stage: 'lost') }
+      let(:o3) { FactoryGirl.create(:opportunity, stage: 'analysis') }
 
       it "should show opportunities which are not lost" do
-        Opportunity.not_lost.should include(o1, o3)
+        expect(Opportunity.not_lost).to include(o1, o3)
       end
 
       it "should not show opportunities which are lost" do
-        Opportunity.not_lost.should_not include(o2)
+        expect(Opportunity.not_lost).not_to include(o2)
       end
     end
   end