fat_free_crm 0.17.3 → 0.18.0

data/spec/models/list_spec.rb

@@ -10,10 +10,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 = build(:list, url: url)
       expect(list.controller).to eq("controller")
     end
-    list = FactoryGirl.build(:list, url: nil)
+    list = build(:list, url: nil)
     expect(list.controller).to eq(nil)
   end
 end

data/spec/models/observers/entity_observer_spec.rb

@@ -15,9 +15,9 @@ describe EntityObserver do
 
   %i[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(:assignee) { create(:user) }
+      let(:assigner) { create(:user) }
+      let!(:entity)  { build(entity_type, user: assigner, assignee: assignee) }
       let(:mail) { double('mail', deliver_now: true) }
 
       after :each do
@@ -45,9 +45,9 @@ describe EntityObserver do
     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(:assignee) { create(:user) }
+      let(:assigner) { create(:user) }
+      let!(:entity)  { create(entity_type, user: create(:user)) }
       let(:mail) { double('mail', deliver_now: true) }
 
       it "notifies the new owner if the entity is re-assigned" do

data/spec/models/polymorphic/address_spec.rb

@@ -29,6 +29,6 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Address do
   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: create(:lead))
   end
 end

data/spec/models/polymorphic/avatar_spec.rb

@@ -24,22 +24,22 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe Avatar do
   before(:each) do
-    @user = FactoryGirl.create(:user)
+    @user = create(:user)
   end
 
   it "should create a new instance given valid attributes" do
-    expect(FactoryGirl.create(:avatar, entity: @user)).to be_valid
+    expect(create(:avatar, entity: @user)).to be_valid
   end
 
   it "user should have one avatar as entity" do
-    avatar = FactoryGirl.create(:avatar, entity: @user)
+    avatar = 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))
+      create(:avatar, user: @user, entity: create(:user)),
+      create(:avatar, user: @user, entity: create(:user))
     ]
     expect(@user.avatars).to eq(avatars)
   end

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) }
+  let(:current_user) { create(:user) }
   before { PaperTrail.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.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.whodunnit)
+        create(:version, event: event, item: @lead, whodunnit: "1")
       end
     end
 
@@ -71,7 +71,7 @@ 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)
+        @item = create(item.to_sym, user: current_user)
         @conditions = { item_id: @item.id, item_type: @item.class.name, whodunnit: PaperTrail.whodunnit }
       end
 
@@ -99,7 +99,7 @@ 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
         expect(@version).not_to eq(nil)
@@ -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,7 +128,7 @@ describe Version, versioning: true do
 
   describe "Action refinements for task updates" do
     before do
-      @task = FactoryGirl.create(:task, user: current_user)
+      @task = create(:task, user: current_user)
       @conditions = { item_id: @task.id, item_type: @task.class.name, whodunnit: PaperTrail.whodunnit }
     end
 
@@ -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,7 +156,7 @@ describe Version, versioning: true do
 
   describe "Rejecting a lead" do
     before do
-      @lead = FactoryGirl.create(:lead, user: current_user, status: "new")
+      @lead = create(:lead, user: current_user, status: "new")
       @conditions = { item_id: @lead.id, item_type: @lead.class.name, whodunnit: PaperTrail.whodunnit }
     end
 
@@ -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)