fat_free_crm 0.17.3 → 0.19.2

data/spec/models/polymorphic/comment_spec.rb

@@ -25,17 +25,17 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Comment do
   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: create(:user), commentable: 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")
+      create(:user, username: "test_user"),
+      create(:user, username: "another_user")
     ]
-    entity = FactoryGirl.create(:lead)
+    entity = create(:lead)
     Comment.create!(comment: "Hey @test_user, take a look at this. Also show @another_user",
-                    user: FactoryGirl.create(:user),
+                    user: create(:user),
                     commentable: entity)
 
     expected_users.each do |user|

data/spec/models/polymorphic/task_spec.rb

@@ -32,11 +32,9 @@
 require 'spec_helper'
 
 describe Task do
-  let(:current_user) { FactoryGirl.create(:user) }
-
   describe "Task/Create" do
     it "should create a new task instance given valid attributes" do
-      task = FactoryGirl.create(:task)
+      task = create(:task)
       expect(task).to be_valid
       expect(task.errors).to be_empty
     end
@@ -47,14 +45,14 @@ describe Task do
       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 = 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.change(usec: 0)).to eq(Time.zone.now.end_of_week.change(usec: 0))
       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 = 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)
@@ -64,23 +62,23 @@ describe Task do
 
   describe "Task/Update" do
     it "should update task name" do
-      task = FactoryGirl.create(:task, name: "Hello")
+      task = 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 = 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)
+      him = create(:user)
+      her = create(:user)
+      task = 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)
@@ -88,8 +86,8 @@ describe Task do
     end
 
     it "should reassign the task from another person to myself" do
-      him = FactoryGirl.create(:user)
-      task = FactoryGirl.create(:task, assigned_to: him.id)
+      him = create(:user)
+      task = create(:task, assigned_to: him.id)
       task.update_attributes(assigned_to: "")
       expect(task.errors).to be_empty
       expect(task.assigned_to).to eq(nil)
@@ -102,7 +100,7 @@ describe Task do
       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 = 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")
@@ -110,7 +108,7 @@ describe Task do
       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 = 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")
@@ -120,45 +118,48 @@ describe Task do
   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)
+    it "should complete a task that is overdue" do
+      task = create(:task, due_at: 2.days.ago, bucket: "overdue")
+      task.update_attributes(completed_at: Time.now, completed_by: task.user.id)
+
       expect(task.errors).to be_empty
       expect(task.completed_at).not_to eq(nil)
-      expect(task.completor).to eq(current_user)
+      expect(task.completor).to eq(task.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 = create(:task, due_at: Time.now.midnight.tomorrow, bucket: "due_tomorrow")
+      task.update_attributes(completed_at: Time.now, completed_by: task.user.id)
+
       expect(task.errors).to be_empty
       expect(task.completed_at).not_to eq(nil)
-      expect(task.completor).to eq(current_user)
+      expect(task.completor).to eq(task.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 = 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.update_attributes(completed_at: Time.now, completed_by: task.user.id)
       expect(task.errors).to be_empty
       expect(task.completed_at).not_to eq(nil)
-      expect(task.completor).to eq(current_user)
+      expect(task.completor).to eq(task.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 = 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.update_attributes(completed_at: Time.now, completed_by: task.user.id)
       expect(task.errors).to be_empty
       expect(task.completed_at).not_to eq(nil)
-      expect(task.completor).to eq(current_user)
+      expect(task.completor).to eq(task.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 = 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: task.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
@@ -166,64 +167,70 @@ describe Task do
 
   # 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
+    let(:current_user) { create(:user) }
+
     it "should match a task created by the user" do
-      task = FactoryGirl.create(:task, user: current_user, assignee: nil)
+      task = 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 = create(:task, user: 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 = create(:task, user: 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 = create(:task, user: current_user, assignee: 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
+    let(:current_user) { create(:user) }
+
     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 = create(:task, user: current_user, assignee: 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 = create(:task, user: 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 = 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 = 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
+    let(:current_user) { create(:user) }
+
     it "should match a task created by the user" do
-      task = FactoryGirl.create(:task, user: current_user)
+      task = 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 = 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 = create(:task, user: create(:user), assignee: create(:user))
       expect(task.tracked_by?(current_user)).to eq(false)
     end
   end
@@ -310,24 +317,24 @@ describe Task do
 
   describe "Exportable" do
     describe "unassigned tasks" do
-      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) }
+      let(:task1) { build(:task, user: create(:user), assignee: nil) }
+      let(:task2) { build(:task, user: create(:user, first_name: nil, last_name: nil), assignee: nil) }
       it_should_behave_like("exportable") do
         let(:exported) { [task1, task2] }
       end
     end
 
     describe "assigned tasks" do
-      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)) }
+      let(:task1) { build(:task, user: create(:user), assignee: create(:user)) }
+      let(:task2) { build(:task, user: create(:user, first_name: nil, last_name: nil), assignee: create(:user, first_name: nil, last_name: nil)) }
       it_should_behave_like("exportable") do
         let(:exported) { [task1, task2] }
       end
     end
 
     describe "completed tasks" do
-      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) }
+      let(:task1) { build(:task, user: create(:user), completor: create(:user), completed_at: 1.day.ago) }
+      let(:task2) { build(:task, user: create(:user, first_name: nil, last_name: nil), completor: create(:user, first_name: nil, last_name: nil), completed_at: 1.day.ago) }
       it_should_behave_like("exportable") do
         let(:exported) { [task1, task2] }
       end
@@ -345,13 +352,13 @@ describe Task do
   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)
+        @user = create(:user)
+        @t1 = create(:task, user: @user)
+        @t2 = create(:task, user: @user, assignee: create(:user))
+        @t3 = create(:task, user: create(:user), assignee: @user)
+        @t4 = create(:task, user: create(:user), assignee: create(:user))
+        @t5 = create(:task, user: create(:user), assignee: @user)
+        @t6 = create(:completed_task, assignee: @user)
       end
 
       it "should show tasks which have been created by the user and are unassigned" do
@@ -377,10 +384,10 @@ describe Task do
 
     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")
+        t1 = create(:task, name: 't1', bucket: "due_asap")
+        t2 = create(:task, calendar: 5.days.from_now.strftime("%Y-%m-%d %H:%M"), bucket: "specific_time")
+        t3 = create(:task, name: 't3', bucket: "due_next_week")
+        t4 = 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

data/spec/models/polymorphic/version_spec.rb

@@ -23,20 +23,20 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Version, versioning: true do
-  let(:current_user) { FactoryGirl.create(:user) }
-  before { PaperTrail.whodunnit = current_user.id.to_s }
+  let(:current_user) { create(:user) }
+  before { PaperTrail.request.whodunnit = current_user.id.to_s }
 
   it "should create a new instance given valid attributes" do
-    FactoryGirl.create(:version, whodunnit: PaperTrail.whodunnit, item: FactoryGirl.create(:lead))
+    create(:version, whodunnit: PaperTrail.request.whodunnit, item: create(:lead))
   end
 
   describe "with multiple version records" do
     before do
-      @lead = FactoryGirl.create(:lead)
+      @lead = create(:lead)
 
       %w[create destroy update view].each do |event|
-        FactoryGirl.create(:version, event: event, item: @lead, whodunnit: PaperTrail.whodunnit)
-        FactoryGirl.create(:version, event: event, item: @lead, whodunnit: "1")
+        create(:version, event: event, item: @lead, whodunnit: PaperTrail.request.whodunnit)
+        create(:version, event: event, item: @lead, whodunnit: "1")
       end
     end
 
@@ -71,8 +71,8 @@ describe Version, versioning: true do
   %w[account campaign contact lead opportunity task].each do |item|
     describe "Create, update, and delete (#{item})" do
       before :each do
-        @item = FactoryGirl.create(item.to_sym, user: current_user)
-        @conditions = { item_id: @item.id, item_type: @item.class.name, whodunnit: PaperTrail.whodunnit }
+        @item = create(item.to_sym, user: current_user)
+        @conditions = { item_id: @item.id, item_type: @item.class.name, whodunnit: PaperTrail.request.whodunnit }
       end
 
       it "should add a version when creating new #{item}" do
@@ -99,9 +99,9 @@ describe Version, versioning: true do
       end
 
       it "should add a version when commenting on a #{item}" do
-        @comment = FactoryGirl.create(:comment, commentable: @item, user: current_user)
+        @comment = create(:comment, commentable: @item, user: current_user)
 
-        @version = Version.where(related_id: @item.id, related_type: @item.class.name, whodunnit: PaperTrail.whodunnit, event: 'create').first
+        @version = Version.where(related_id: @item.id, related_type: @item.class.name, whodunnit: PaperTrail.request.whodunnit, event: 'create').first
         expect(@version).not_to eq(nil)
       end
     end
@@ -109,7 +109,7 @@ describe Version, versioning: true do
 
   describe "Recently viewed items (task)" do
     before do
-      @task = FactoryGirl.create(:task)
+      @task = create(:task)
       @conditions = { item_id: @task.id, item_type: @task.class.name }
     end
 
@@ -128,8 +128,8 @@ describe Version, versioning: true do
 
   describe "Action refinements for task updates" do
     before do
-      @task = FactoryGirl.create(:task, user: current_user)
-      @conditions = { item_id: @task.id, item_type: @task.class.name, whodunnit: PaperTrail.whodunnit }
+      @task = create(:task, user: current_user)
+      @conditions = { item_id: @task.id, item_type: @task.class.name, whodunnit: PaperTrail.request.whodunnit }
     end
 
     it "should create 'completed' task event" do
@@ -147,7 +147,7 @@ describe Version, versioning: true do
     end
 
     it "should create 'rescheduled' task event" do
-      @task.update(bucket: "due_tomorrow") # FactoryGirl creates :due_asap task
+      @task.update(bucket: "due_tomorrow") # FactoryBot creates :due_asap task
 
       versions = Version.where(@conditions)
       expect(versions.pluck(:event)).to include('reschedule')
@@ -156,8 +156,8 @@ describe Version, versioning: true do
 
   describe "Rejecting a lead" do
     before do
-      @lead = FactoryGirl.create(:lead, user: current_user, status: "new")
-      @conditions = { item_id: @lead.id, item_type: @lead.class.name, whodunnit: PaperTrail.whodunnit }
+      @lead = create(:lead, user: current_user, status: "new")
+      @conditions = { item_id: @lead.id, item_type: @lead.class.name, whodunnit: PaperTrail.request.whodunnit }
     end
 
     it "should create 'rejected' lead event" do
@@ -170,12 +170,12 @@ describe Version, versioning: true do
 
   describe "Permissions" do
     before do
-      @user = FactoryGirl.create(:user)
+      @user = create(:user)
       Version.delete_all
     end
 
     it "should not show the create/update versions if the item is private" do
-      @item = FactoryGirl.create(:account, user: current_user, access: "Private")
+      @item = create(:account, user: current_user, access: "Private")
       @item.update(name: 'New Name')
 
       versions = Version.where(item_id: @item.id, item_type: @item.class.name)
@@ -186,7 +186,7 @@ describe Version, versioning: true do
     end
 
     it "should not show the destroy version if the item is private" do
-      @item = FactoryGirl.create(:account, user: current_user, access: "Private")
+      @item = create(:account, user: current_user, access: "Private")
       @item.destroy
 
       versions = Version.where(item_id: @item.id, item_type: @item.class.name)
@@ -197,10 +197,10 @@ describe Version, versioning: true do
     end
 
     it "should not show create/update versions if the item was not shared with the user" do
-      @item = FactoryGirl.create(:account,
-                                 user: current_user,
-                                 access: "Shared",
-                                 permissions: [FactoryGirl.build(:permission, user: current_user, asset: @item)])
+      @item = create(:account,
+                     user: current_user,
+                     access: "Shared",
+                     permissions: [build(:permission, user: current_user, asset: @item)])
       @item.update(name: 'New Name')
 
       versions = Version.where(item_id: @item.id, item_type: @item.class.name)
@@ -211,10 +211,10 @@ describe Version, versioning: true do
     end
 
     it "should not show the destroy version if the item was not shared with the user" do
-      @item = FactoryGirl.create(:account,
-                                 user: current_user,
-                                 access: "Shared",
-                                 permissions: [FactoryGirl.build(:permission, user: current_user, asset: @item)])
+      @item = create(:account,
+                     user: current_user,
+                     access: "Shared",
+                     permissions: [build(:permission, user: current_user, asset: @item)])
       @item.destroy
 
       versions = Version.where(item_id: @item.id, item_type: @item.class.name)
@@ -225,10 +225,10 @@ describe Version, versioning: true do
     end
 
     it "should show create/update versions if the item was shared with the user" do
-      @item = FactoryGirl.create(:account,
-                                 user: current_user,
-                                 access: "Shared",
-                                 permissions: [FactoryGirl.build(:permission, user: @user, asset: @item)])
+      @item = create(:account,
+                     user: current_user,
+                     access: "Shared",
+                     permissions: [build(:permission, user: @user, asset: @item)])
       @item.update(name: 'New Name')
 
       versions = Version.where(item_id: @item.id, item_type: @item.class.name)