fat_free_crm 0.13.6 → 0.14.0

data/spec/models/list_spec.rb

@@ -8,10 +8,10 @@ require 'spec_helper'
 describe List do
   it "should parse the controller from the url" do
     ["/controller/action", "controller/action?utf8=%E2%9C%93"].each do |url|
-      list = FactoryGirl.build(:list, :url => url)
-      list.controller.should == "controller"
+      list = FactoryGirl.build(:list, url: url)
+      expect(list.controller).to eq("controller")
     end
-    list = FactoryGirl.build(:list, :url => nil)
-    list.controller.should == nil
+    list = FactoryGirl.build(:list, url: nil)
+    expect(list.controller).to eq(nil)
   end
 end

data/spec/models/observers/entity_observer_spec.rb

@@ -6,70 +6,67 @@
 require 'spec_helper'
 
 describe EntityObserver do
-
   before do
-    Setting.stub(:host).and_return('http://www.example.com')
-    PaperTrail.stub(:whodunnit).and_return(assigner)
+    allow(Setting).to receive(:host).and_return('http://www.example.com')
+    allow(PaperTrail).to receive(:whodunnit).and_return(assigner)
   end
 
   [:account, :contact, :lead, :opportunity].each do |entity_type|
     describe "on creation of #{entity_type}" do
       let(:assignee) { FactoryGirl.create(:user) }
       let(:assigner) { FactoryGirl.create(:user) }
-      let!(:entity)  { FactoryGirl.build(entity_type, :user => assigner, :assignee => assignee) }
-      let(:mail) { double('mail', :deliver => true) }
+      let!(:entity)  { FactoryGirl.build(entity_type, user: assigner, assignee: assignee) }
+      let(:mail) { double('mail', deliver_now: true) }
 
       after :each do
         entity.save
       end
 
       it "sends notification to the assigned user for entity" do
-        UserMailer.should_receive(:assigned_entity_notification).with(entity, assigner).and_return(mail)
+        expect(UserMailer).to receive(:assigned_entity_notification).with(entity, assigner).and_return(mail)
       end
 
       it "does not notify anyone if the entity is created and assigned to no-one" do
         entity.assignee = nil
-        UserMailer.should_not_receive(:assigned_entity_notification)
+        expect(UserMailer).not_to receive(:assigned_entity_notification)
       end
 
       it "does not notify me if I have created an entity for myself" do
         entity.assignee = entity.user = assigner
-        UserMailer.should_not_receive(:assigned_entity_notification)
+        expect(UserMailer).not_to receive(:assigned_entity_notification)
       end
 
       it "does not notify me if Setting.host has not been set" do
-        Setting.stub(:host).and_return('')
-        UserMailer.should_not_receive(:assigned_entity_notification)
+        allow(Setting).to receive(:host).and_return('')
+        expect(UserMailer).not_to receive(:assigned_entity_notification)
       end
-
     end
 
     describe "on update of #{entity_type}" do
       let(:assignee) { FactoryGirl.create(:user) }
       let(:assigner) { FactoryGirl.create(:user) }
-      let!(:entity)  { FactoryGirl.create(entity_type, :user => FactoryGirl.create(:user)) }
-      let(:mail) { double('mail', :deliver => true) }
+      let!(:entity)  { FactoryGirl.create(entity_type, user: FactoryGirl.create(:user)) }
+      let(:mail) { double('mail', deliver_now: true) }
 
       it "notifies the new owner if the entity is re-assigned" do
-        UserMailer.should_receive(:assigned_entity_notification).with(entity, assigner).and_return(mail)
-        entity.update_attributes(:assignee => assignee)
+        expect(UserMailer).to receive(:assigned_entity_notification).with(entity, assigner).and_return(mail)
+        entity.update_attributes(assignee: assignee)
       end
 
       it "does not notify the owner if the entity is not re-assigned" do
-        UserMailer.should_not_receive(:assigned_entity_notification)
+        expect(UserMailer).not_to receive(:assigned_entity_notification)
         entity.touch
       end
 
       it "does not notify anyone if the entity becomes unassigned" do
-        UserMailer.should_not_receive(:assigned_entity_notification)
-        entity.update_attributes(:assignee => nil)
+        expect(UserMailer).not_to receive(:assigned_entity_notification)
+        entity.update_attributes(assignee: nil)
       end
 
       it "does not notify me if I re-assign an entity to myself" do
-        UserMailer.should_not_receive(:assigned_entity_notification)
-        entity.update_attributes(:assignee => assigner)
+        expect(UserMailer).not_to receive(:assigned_entity_notification)
+        entity.update_attributes(assignee: assigner)
       end
     end
-
   end
 end

data/spec/models/polymorphic/address_spec.rb

@@ -26,13 +26,11 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Address do
-
   before(:each) do
     login
   end
 
   it "should create a new instance given valid attributes" do
-    Address.create!(:street1 => "street1", :street2 => "street2", :city => "city", :state => "state", :zipcode => "zipcode", :country => "country", :full_address => "fa", :address_type => "Lead", :addressable => FactoryGirl.create(:lead))
+    Address.create!(street1: "street1", street2: "street2", city: "city", state: "state", zipcode: "zipcode", country: "country", full_address: "fa", address_type: "Lead", addressable: FactoryGirl.create(:lead))
   end
 end
-

data/spec/models/polymorphic/avatar_spec.rb

@@ -26,21 +26,19 @@ describe Avatar do
   end
 
   it "should create a new instance given valid attributes" do
-    FactoryGirl.create(:avatar, :entity => @user).should be_valid
+    expect(FactoryGirl.create(:avatar, entity: @user)).to be_valid
   end
 
   it "user should have one avatar as entity" do
-    avatar = FactoryGirl.create(:avatar, :entity => @user)
-    @user.avatar.should == avatar
+    avatar = FactoryGirl.create(:avatar, entity: @user)
+    expect(@user.avatar).to eq(avatar)
   end
 
   it "user might have many avatars as owner" do
     avatars = [
-      FactoryGirl.create(:avatar, :user=> @user, :entity => FactoryGirl.create(:user)),
-      FactoryGirl.create(:avatar, :user=> @user, :entity => FactoryGirl.create(:user))
+      FactoryGirl.create(:avatar, user: @user, entity: FactoryGirl.create(:user)),
+      FactoryGirl.create(:avatar, user: @user, entity: FactoryGirl.create(:user))
     ]
-    @user.avatars.should == avatars
+    expect(@user.avatars).to eq(avatars)
   end
-
 end
-

data/spec/models/polymorphic/comment_spec.rb

@@ -22,28 +22,26 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Comment do
-
   before(:each) do
     login
   end
 
   it "should create a new instance given valid attributes" do
-    Comment.create!(:comment => "Hello", :user => FactoryGirl.create(:user), :commentable => FactoryGirl.create(:lead))
+    Comment.create!(comment: "Hello", user: FactoryGirl.create(:user), commentable: FactoryGirl.create(:lead))
   end
 
   it "should subscribe users mentioned in the comment to the entity, and notify them via email" do
     expected_users = [
-      FactoryGirl.create(:user, :username => "test_user"),
-      FactoryGirl.create(:user, :username => "another_user")
+      FactoryGirl.create(:user, username: "test_user"),
+      FactoryGirl.create(:user, username: "another_user")
     ]
     entity = FactoryGirl.create(:lead)
-    Comment.create!(:comment => "Hey @test_user, take a look at this. Also show @another_user",
-                    :user => FactoryGirl.create(:user),
-                    :commentable => entity)
+    Comment.create!(comment: "Hey @test_user, take a look at this. Also show @another_user",
+                    user: FactoryGirl.create(:user),
+                    commentable: entity)
 
     expected_users.each do |user|
-      entity.subscribed_users.should include(user.id)
+      expect(entity.subscribed_users).to include(user.id)
     end
   end
 end
-

data/spec/models/polymorphic/email_spec.rb

@@ -35,7 +35,6 @@ describe Email do
   end
 
   it "should be valid" do
-    @email.should be_valid
+    expect(@email).to be_valid
   end
 end
-

data/spec/models/polymorphic/task_spec.rb

@@ -29,227 +29,224 @@
 require 'spec_helper'
 
 describe Task do
-
   before { login }
 
   describe "Task/Create" do
     it "should create a new task instance given valid attributes" do
       task = FactoryGirl.create(:task)
-      task.should be_valid
-      task.errors.should be_empty
+      expect(task).to be_valid
+      expect(task.errors).to be_empty
     end
 
-    [ nil, Time.now.utc_offset + 3600 ].each do |offset|
+    [nil, Time.now.utc_offset + 3600].each do |offset|
       before do
         adjust_timezone(offset)
       end
 
       it "should create a task with due date selected from dropdown within #{offset ? 'different' : 'current'} timezone" do
-        task = FactoryGirl.create(:task, :due_at => Time.now.end_of_week, :bucket => "due_this_week")
-        task.errors.should be_empty
-        task.bucket.should == "due_this_week"
-        task.due_at.should == Time.zone.now.end_of_week
+        task = FactoryGirl.create(:task, due_at: Time.now.end_of_week, bucket: "due_this_week")
+        expect(task.errors).to be_empty
+        expect(task.bucket).to eq("due_this_week")
+        expect(task.due_at).to eq(Time.zone.now.end_of_week)
       end
 
       it "should create a task with due date selected from the calendar within #{offset ? 'different' : 'current'} timezone" do
-        task = FactoryGirl.create(:task, :bucket => "specific_time", :calendar => "2020-03-20")
-        task.errors.should be_empty
-        task.bucket.should == "specific_time"
-        task.due_at.to_i.should == Time.parse("2020-03-20").to_i
+        task = FactoryGirl.create(:task, bucket: "specific_time", calendar: "2020-03-20")
+        expect(task.errors).to be_empty
+        expect(task.bucket).to eq("specific_time")
+        expect(task.due_at.to_i).to eq(Time.parse("2020-03-20").to_i)
       end
     end
   end
 
   describe "Task/Update" do
     it "should update task name" do
-      task = FactoryGirl.create(:task, :name => "Hello")
-      task.update_attributes({ :name => "World"})
-      task.errors.should be_empty
-      task.name.should == "World"
+      task = FactoryGirl.create(:task, name: "Hello")
+      task.update_attributes(name: "World")
+      expect(task.errors).to be_empty
+      expect(task.name).to eq("World")
     end
 
     it "should update task category" do
-      task = FactoryGirl.create(:task, :category => "call")
-      task.update_attributes({ :category => "email" })
-      task.errors.should be_empty
-      task.category.should == "email"
+      task = FactoryGirl.create(:task, category: "call")
+      task.update_attributes(category: "email")
+      expect(task.errors).to be_empty
+      expect(task.category).to eq("email")
     end
 
     it "should reassign the task to another person" do
       him = FactoryGirl.create(:user)
       her = FactoryGirl.create(:user)
-      task = FactoryGirl.create(:task, :assigned_to => him.id)
-      task.update_attributes( { :assigned_to => her.id } )
-      task.errors.should be_empty
-      task.assigned_to.should == her.id
-      task.assignee.should == her
+      task = FactoryGirl.create(:task, assigned_to: him.id)
+      task.update_attributes(assigned_to: her.id)
+      expect(task.errors).to be_empty
+      expect(task.assigned_to).to eq(her.id)
+      expect(task.assignee).to eq(her)
     end
 
     it "should reassign the task from another person to myself" do
       him = FactoryGirl.create(:user)
-      task = FactoryGirl.create(:task, :assigned_to => him.id)
-      task.update_attributes( { :assigned_to => "" } )
-      task.errors.should be_empty
-      task.assigned_to.should == nil
-      task.assignee.should == nil
+      task = FactoryGirl.create(:task, assigned_to: him.id)
+      task.update_attributes(assigned_to: "")
+      expect(task.errors).to be_empty
+      expect(task.assigned_to).to eq(nil)
+      expect(task.assignee).to eq(nil)
     end
 
-    [ nil, Time.now.utc_offset + 3600 ].each do |offset|
+    [nil, Time.now.utc_offset + 3600].each do |offset|
       before do
         adjust_timezone(offset)
       end
 
       it "should update due date based on selected bucket within #{offset ? 'different' : 'current'} timezone" do
-        task = FactoryGirl.create(:task, :due_at => Time.now.midnight.tomorrow, :bucket => "due_tomorrow")
-        task.update_attributes( { :bucket => "due_this_week" } )
-        task.errors.should be_empty
-        task.bucket.should == "due_this_week"
-        task.due_at.should == Time.zone.now.end_of_week
+        task = FactoryGirl.create(:task, due_at: Time.now.midnight.tomorrow, bucket: "due_tomorrow")
+        task.update_attributes(bucket: "due_this_week")
+        expect(task.errors).to be_empty
+        expect(task.bucket).to eq("due_this_week")
+        expect(task.due_at).to eq(Time.zone.now.end_of_week)
       end
 
       it "should update due date if specific calendar date selected within #{offset ? 'different' : 'current'} timezone" do
-        task = FactoryGirl.create(:task, :due_at => Time.now.midnight.tomorrow, :bucket => "due_tomorrow")
-        task.update_attributes( { :bucket => "specific_time", :calendar => "2020-03-20" } )
-        task.errors.should be_empty
-        task.bucket.should == "specific_time"
-        task.due_at.to_i.should == Time.parse("2020-03-20").to_i
+        task = FactoryGirl.create(:task, due_at: Time.now.midnight.tomorrow, bucket: "due_tomorrow")
+        task.update_attributes(bucket: "specific_time", calendar: "2020-03-20")
+        expect(task.errors).to be_empty
+        expect(task.bucket).to eq("specific_time")
+        expect(task.due_at.to_i).to eq(Time.parse("2020-03-20").to_i)
       end
     end
-
   end
 
   describe "Task/Complete" do
     it "should comlete a task that is overdue" do
-      task = FactoryGirl.create(:task, :due_at => 2.days.ago, :bucket => "overdue")
-      task.update_attributes(:completed_at => Time.now, :completed_by => current_user.id)
-      task.errors.should be_empty
-      task.completed_at.should_not == nil
-      task.completor.should == current_user
+      task = FactoryGirl.create(:task, due_at: 2.days.ago, bucket: "overdue")
+      task.update_attributes(completed_at: Time.now, completed_by: current_user.id)
+      expect(task.errors).to be_empty
+      expect(task.completed_at).not_to eq(nil)
+      expect(task.completor).to eq(current_user)
     end
 
     it "should complete a task due sometime in the future" do
-      task = FactoryGirl.create(:task, :due_at => Time.now.midnight.tomorrow, :bucket => "due_tomorrow")
-      task.update_attributes(:completed_at => Time.now, :completed_by => current_user.id)
-      task.errors.should be_empty
-      task.completed_at.should_not == nil
-      task.completor.should == current_user
+      task = FactoryGirl.create(:task, due_at: Time.now.midnight.tomorrow, bucket: "due_tomorrow")
+      task.update_attributes(completed_at: Time.now, completed_by: current_user.id)
+      expect(task.errors).to be_empty
+      expect(task.completed_at).not_to eq(nil)
+      expect(task.completor).to eq(current_user)
     end
 
     it "should complete a task that is due on specific date in the future" do
-      task = FactoryGirl.create(:task, :calendar => "10/10/2022 12:00 AM", :bucket => "specific_time")
+      task = FactoryGirl.create(:task, calendar: "10/10/2022 12:00 AM", bucket: "specific_time")
       task.calendar = nil # Calendar is not saved in the database; we need it only to set the :due_at.
-      task.update_attributes(:completed_at => Time.now, :completed_by => current_user.id)
-      task.errors.should be_empty
-      task.completed_at.should_not == nil
-      task.completor.should == current_user
+      task.update_attributes(completed_at: Time.now, completed_by: current_user.id)
+      expect(task.errors).to be_empty
+      expect(task.completed_at).not_to eq(nil)
+      expect(task.completor).to eq(current_user)
     end
 
     it "should complete a task that is due on specific date in the past" do
-      task = FactoryGirl.create(:task, :calendar => "10/10/1992 12:00 AM", :bucket => "specific_time")
+      task = FactoryGirl.create(:task, calendar: "10/10/1992 12:00 AM", bucket: "specific_time")
       task.calendar = nil # Calendar is not saved in the database; we need it only to set the :due_at.
-      task.update_attributes(:completed_at => Time.now, :completed_by => current_user.id)
-      task.errors.should be_empty
-      task.completed_at.should_not == nil
-      task.completor.should == current_user
+      task.update_attributes(completed_at: Time.now, completed_by: current_user.id)
+      expect(task.errors).to be_empty
+      expect(task.completed_at).not_to eq(nil)
+      expect(task.completor).to eq(current_user)
     end
 
     it "completion should preserve original due date" do
       due_at = Time.now - 42.days
-      task = FactoryGirl.create(:task, :due_at => due_at, :bucket => "specific_time",
-                            :calendar => due_at.strftime('%Y-%m-%d %H:%M'))
-      task.update_attributes(:completed_at => Time.now, :completed_by => current_user.id, :calendar => '')
-      task.completed?.should == true
-      task.due_at.should == due_at.utc.strftime('%Y-%m-%d %H:%M')
+      task = FactoryGirl.create(:task, due_at: due_at, bucket: "specific_time",
+                                       calendar: due_at.strftime('%Y-%m-%d %H:%M'))
+      task.update_attributes(completed_at: Time.now, completed_by: current_user.id, calendar: '')
+      expect(task.completed?).to eq(true)
+      expect(task.due_at).to eq(due_at.utc.strftime('%Y-%m-%d %H:%M'))
     end
   end
 
   # named_scope :my, lambda { |user| { :conditions => [ "(user_id = ? AND assigned_to IS NULL) OR assigned_to = ?", user.id, user.id ], :include => :assignee } }
   describe "task.my?" do
     it "should match a task created by the user" do
-      task = FactoryGirl.create(:task, :user => current_user, :assignee => nil)
-      task.my?(current_user).should == true
+      task = FactoryGirl.create(:task, user: current_user, assignee: nil)
+      expect(task.my?(current_user)).to eq(true)
     end
 
     it "should match a task assigned to the user" do
-      task = FactoryGirl.create(:task, :user => FactoryGirl.create(:user), :assignee => current_user)
-      task.my?(current_user).should == true
+      task = FactoryGirl.create(:task, user: FactoryGirl.create(:user), assignee: current_user)
+      expect(task.my?(current_user)).to eq(true)
     end
 
     it "should Not match a task not created by the user" do
-      task = FactoryGirl.create(:task, :user => FactoryGirl.create(:user))
-      task.my?(current_user).should == false
+      task = FactoryGirl.create(:task, user: FactoryGirl.create(:user))
+      expect(task.my?(current_user)).to eq(false)
     end
 
     it "should Not match a task created by the user but assigned to somebody else" do
-      task = FactoryGirl.create(:task, :user => current_user, :assignee => FactoryGirl.create(:user))
-      task.my?(current_user).should == false
+      task = FactoryGirl.create(:task, user: current_user, assignee: FactoryGirl.create(:user))
+      expect(task.my?(current_user)).to eq(false)
     end
   end
 
   # named_scope :assigned_by, lambda { |user| { :conditions => [ "user_id = ? AND assigned_to IS NOT NULL AND assigned_to != ?", user.id, user.id ], :include => :assignee } }
   describe "task.assigned_by?" do
     it "should match a task assigned by the user to somebody else" do
-      task = FactoryGirl.create(:task, :user => current_user, :assignee => FactoryGirl.create(:user))
-      task.assigned_by?(current_user).should == true
+      task = FactoryGirl.create(:task, user: current_user, assignee: FactoryGirl.create(:user))
+      expect(task.assigned_by?(current_user)).to eq(true)
     end
 
     it "should Not match a task not created by the user" do
-      task = FactoryGirl.create(:task, :user => FactoryGirl.create(:user))
-      task.assigned_by?(current_user).should == false
+      task = FactoryGirl.create(:task, user: FactoryGirl.create(:user))
+      expect(task.assigned_by?(current_user)).to eq(false)
     end
 
     it "should Not match a task not assigned to anybody" do
-      task = FactoryGirl.create(:task, :assignee => nil)
-      task.assigned_by?(current_user).should == false
+      task = FactoryGirl.create(:task, assignee: nil)
+      expect(task.assigned_by?(current_user)).to eq(false)
     end
 
     it "should Not match a task assigned to the user" do
-      task = FactoryGirl.create(:task, :assignee => current_user)
-      task.assigned_by?(current_user).should == false
+      task = FactoryGirl.create(:task, assignee: current_user)
+      expect(task.assigned_by?(current_user)).to eq(false)
     end
   end
 
   # named_scope :tracked_by, lambda { |user| { :conditions => [ "user_id = ? OR assigned_to = ?", user.id, user.id ], :include => :assignee } }
   describe "task.tracked_by?" do
     it "should match a task created by the user" do
-      task = FactoryGirl.create(:task, :user => current_user)
-      task.tracked_by?(current_user).should == true
+      task = FactoryGirl.create(:task, user: current_user)
+      expect(task.tracked_by?(current_user)).to eq(true)
     end
 
     it "should match a task assigned to the user" do
-      task = FactoryGirl.create(:task, :assignee => current_user)
-      task.tracked_by?(current_user).should == true
+      task = FactoryGirl.create(:task, assignee: current_user)
+      expect(task.tracked_by?(current_user)).to eq(true)
     end
 
     it "should Not match a task that is neither created nor assigned to the user" do
-      task = FactoryGirl.create(:task, :user => FactoryGirl.create(:user), :assignee => FactoryGirl.create(:user))
-      task.tracked_by?(current_user).should == false
+      task = FactoryGirl.create(:task, user: FactoryGirl.create(:user), assignee: FactoryGirl.create(:user))
+      expect(task.tracked_by?(current_user)).to eq(false)
     end
   end
 
   describe "task.computed_bucket" do
-
     context "when overdue" do
-      subject { described_class.new(:due_at => 1.days.ago, :bucket => "specific_time") }
+      subject { described_class.new(due_at: 1.days.ago, bucket: "specific_time") }
 
       it "returns a sensible value" do
-        subject.computed_bucket.should == "overdue"
+        expect(subject.computed_bucket).to eq("overdue")
       end
     end
 
     context "when due today" do
-      subject { described_class.new(:due_at => Time.now, :bucket => "specific_time") }
+      subject { described_class.new(due_at: Time.now, bucket: "specific_time") }
 
       it "returns a sensible value" do
-        subject.computed_bucket.should == "due_today"
+        expect(subject.computed_bucket).to eq("due_today")
       end
     end
 
     context "when due tomorrow" do
-      subject { described_class.new(:due_at => 1.days.from_now.end_of_day, :bucket => "specific_time") }
+      subject { described_class.new(due_at: 1.days.from_now.end_of_day, bucket: "specific_time") }
 
       it "returns a sensible value" do
-        subject.computed_bucket.should == "due_tomorrow"
+        expect(subject.computed_bucket).to eq("due_tomorrow")
       end
     end
 
@@ -257,25 +254,27 @@ describe Task do
       it "returns a sensible value" do
         # Freeze time so tests will pass when run at the end of the week!!
         Timecop.freeze(Time.local(2014, 1, 1, 16, 14)) do
-          task = described_class.new(:due_at => Time.zone.now.end_of_week, :bucket => "specific_time")
+          task = described_class.new(due_at: Time.zone.now.end_of_week, bucket: "specific_time")
           expect(task.computed_bucket).to eql("due_this_week")
         end
       end
     end
 
     context "when due next week" do
-      subject { described_class.new(:due_at => Time.zone.now.next_week, :bucket => "specific_time") }
+      subject { described_class.new(due_at: Time.zone.now.next_week, bucket: "specific_time") }
 
       it "returns a sensible value" do
-        subject.computed_bucket.should == "due_next_week"
+        Timecop.freeze(Time.local(2014, 1, 1, 16, 14)) do
+          expect(subject.computed_bucket).to eq("due_next_week")
+        end
       end
     end
 
     context "when due later" do
-      subject { described_class.new(:due_at => 1.month.from_now, :bucket => "specific_time") }
+      subject { described_class.new(due_at: 1.month.from_now, bucket: "specific_time") }
 
       it "returns a sensible value" do
-        subject.computed_bucket.should == "due_later"
+        expect(subject.computed_bucket).to eq("due_later")
       end
     end
   end
@@ -285,7 +284,7 @@ describe Task do
       subject { described_class.new(due_at: Time.zone.now.beginning_of_day) }
 
       it "returns false" do
-        subject.at_specific_time?.should == false
+        expect(subject.at_specific_time?).to eq(false)
       end
     end
 
@@ -293,7 +292,7 @@ describe Task do
       subject { described_class.new(due_at: Time.zone.now.end_of_day) }
 
       it "returns false" do
-        subject.at_specific_time?.should == false
+        expect(subject.at_specific_time?).to eq(false)
       end
     end
 
@@ -301,96 +300,85 @@ describe Task do
       subject { described_class.new(due_at: Time.zone.parse("2014-01-01 18:36:43")) }
 
       it "returns true" do
-        subject.at_specific_time?.should == true
+        expect(subject.at_specific_time?).to eq(true)
       end
     end
   end
 
   describe "Exportable" do
     describe "unassigned tasks" do
-      before do
-        Task.delete_all
-        FactoryGirl.create(:task, :user => FactoryGirl.create(:user), :assignee => nil)
-        FactoryGirl.create(:task, :user => FactoryGirl.create(:user, :first_name => nil, :last_name => nil), :assignee => nil)
-      end
+      let(:task1) { FactoryGirl.build(:task, user: FactoryGirl.create(:user), assignee: nil) }
+      let(:task2) { FactoryGirl.build(:task, user: FactoryGirl.create(:user, first_name: nil, last_name: nil), assignee: nil) }
       it_should_behave_like("exportable") do
-        let(:exported) { Task.all }
+        let(:exported) { [task1, task2] }
       end
     end
 
     describe "assigned tasks" do
-      before do
-        Task.delete_all
-        FactoryGirl.create(:task, :user => FactoryGirl.create(:user), :assignee => FactoryGirl.create(:user))
-        FactoryGirl.create(:task, :user => FactoryGirl.create(:user, :first_name => nil, :last_name => nil), :assignee => FactoryGirl.create(:user, :first_name => nil, :last_name => nil))
-      end
+      let(:task1) { FactoryGirl.build(:task, user: FactoryGirl.create(:user), assignee: FactoryGirl.create(:user)) }
+      let(:task2) { FactoryGirl.build(:task, 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) { Task.all }
+        let(:exported) { [task1, task2] }
       end
     end
 
     describe "completed tasks" do
-      before do
-        Task.delete_all
-        FactoryGirl.create(:task, :user => FactoryGirl.create(:user), :completor => FactoryGirl.create(:user), :completed_at => 1.day.ago)
-        FactoryGirl.create(:task, :user => FactoryGirl.create(:user, :first_name => nil, :last_name => nil), :completor => FactoryGirl.create(:user, :first_name => nil, :last_name => nil), :completed_at => 1.day.ago)
-      end
+      let(:task1) { FactoryGirl.build(:task, user: FactoryGirl.create(:user), completor: FactoryGirl.create(:user), completed_at: 1.day.ago) }
+      let(:task2) { FactoryGirl.build(:task, user: FactoryGirl.create(:user, first_name: nil, last_name: nil), completor: FactoryGirl.create(:user, first_name: nil, last_name: nil), completed_at: 1.day.ago) }
       it_should_behave_like("exportable") do
-        let(:exported) { Task.all }
+        let(:exported) { [task1, task2] }
       end
     end
   end
 
   describe "#parse_calendar_date" do
-
     it "should parse the date" do
-      @task = Task.new(:calendar => '2020-12-23')
-      Time.should_receive(:parse).with('2020-12-23')
+      @task = Task.new(calendar: '2020-12-23')
+      expect(Time).to receive(:parse).with('2020-12-23')
       @task.send(:parse_calendar_date)
     end
-
   end
 
   describe "scopes" do
     context "visible_on_dashboard" do
       before :each do
         @user = FactoryGirl.create(:user)
-        @t1 = FactoryGirl.create(:task, :user => @user)
-        @t2 = FactoryGirl.create(:task, :user => @user, :assignee => FactoryGirl.create(:user))
-        @t3 = FactoryGirl.create(:task, :user => FactoryGirl.create(:user), :assignee => @user)
-        @t4 = FactoryGirl.create(:task, :user => FactoryGirl.create(:user), :assignee => FactoryGirl.create(:user))
-        @t5 = FactoryGirl.create(:task, :user => FactoryGirl.create(:user), :assignee => @user)
-        @t6 = FactoryGirl.create(:completed_task, :assignee => @user)
+        @t1 = FactoryGirl.create(:task, user: @user)
+        @t2 = FactoryGirl.create(:task, user: @user, assignee: FactoryGirl.create(:user))
+        @t3 = FactoryGirl.create(:task, user: FactoryGirl.create(:user), assignee: @user)
+        @t4 = FactoryGirl.create(:task, user: FactoryGirl.create(:user), assignee: FactoryGirl.create(:user))
+        @t5 = FactoryGirl.create(:task, user: FactoryGirl.create(:user), assignee: @user)
+        @t6 = FactoryGirl.create(:completed_task, assignee: @user)
       end
 
       it "should show tasks which have been created by the user and are unassigned" do
-        Task.visible_on_dashboard(@user).should include(@t1)
+        expect(Task.visible_on_dashboard(@user)).to include(@t1)
       end
 
       it "should show tasks which are assigned to the user" do
-        Task.visible_on_dashboard(@user).should include(@t3, @t5)
+        expect(Task.visible_on_dashboard(@user)).to include(@t3, @t5)
       end
 
       it "should not show tasks which are not assigned to the user" do
-        Task.visible_on_dashboard(@user).should_not include(@t4)
+        expect(Task.visible_on_dashboard(@user)).not_to include(@t4)
       end
 
       it "should not show tasks which are created by the user but assigned" do
-        Task.visible_on_dashboard(@user).should_not include(@t2)
+        expect(Task.visible_on_dashboard(@user)).not_to include(@t2)
       end
 
       it "should not include completed tasks" do
-        Task.visible_on_dashboard(@user).should_not include(@t6)
+        expect(Task.visible_on_dashboard(@user)).not_to include(@t6)
       end
     end
 
     context "by_due_at" do
       it "should show tasks ordered by due_at" do
-        t1 = FactoryGirl.create(:task, :name => 't1', :bucket => "due_asap")
-        t2 = FactoryGirl.create(:task, :calendar => 5.days.from_now.strftime("%Y-%m-%d %H:%M"), :bucket => "specific_time")
-        t3 = FactoryGirl.create(:task, :name => 't3',  :bucket => "due_next_week")
-        t4 = FactoryGirl.create(:task, :calendar => 20.days.from_now.strftime("%Y-%m-%d %H:%M"), :bucket => "specific_time")
-        Task.by_due_at.should == [t1, t2, t3, t4]
+        t1 = FactoryGirl.create(:task, name: 't1', bucket: "due_asap")
+        t2 = FactoryGirl.create(:task, calendar: 5.days.from_now.strftime("%Y-%m-%d %H:%M"), bucket: "specific_time")
+        t3 = FactoryGirl.create(:task, name: 't3',  bucket: "due_next_week")
+        t4 = FactoryGirl.create(:task, calendar: 20.days.from_now.strftime("%Y-%m-%d %H:%M"), bucket: "specific_time")
+        expect(Task.by_due_at).to eq([t1, t2, t3, t4])
       end
     end
   end