fat_free_crm 0.17.1 → 0.18.2

data/spec/models/fields/custom_field_spec.rb

@@ -35,16 +35,16 @@ describe CustomField do
     expect(Contact).to receive(:reset_column_information)
     expect(Contact).to receive(:serialize_custom_fields!)
 
-    FactoryGirl.create(:custom_field,
-                       as: "string",
-                       name: "cf_test_field",
-                       label: "Test Field",
-                       field_group: FactoryGirl.create(:field_group, klass_name: "Contact"))
+    create(:custom_field,
+           as: "string",
+           name: "cf_test_field",
+           label: "Test Field",
+           field_group: create(:field_group, klass_name: "Contact"))
   end
 
   it "should generate a unique column name for a custom field" do
-    field_group = FactoryGirl.build(:field_group, klass_name: "Contact")
-    c = FactoryGirl.build(:custom_field, label: "Test Field", field_group: field_group)
+    field_group = build(:field_group, klass_name: "Contact")
+    c = build(:custom_field, label: "Test Field", field_group: field_group)
 
     columns = []
     %w[cf_test_field cf_test_field_2 cf_test_field_3 cf_test_field_4].each do |field|
@@ -54,12 +54,12 @@ describe CustomField do
   end
 
   it "should evaluate the safety of database transitions" do
-    c = FactoryGirl.build(:custom_field, as: "string")
+    c = build(:custom_field, as: "string")
     expect(c.send(:db_transition_safety, c.as, "email")).to eq(:null)
     expect(c.send(:db_transition_safety, c.as, "text")).to eq(:safe)
     expect(c.send(:db_transition_safety, c.as, "datetime")).to eq(:unsafe)
 
-    c = FactoryGirl.build(:custom_field, as: "datetime")
+    c = build(:custom_field, as: "datetime")
     expect(c.send(:db_transition_safety, c.as, "date")).to eq(:safe)
     expect(c.send(:db_transition_safety, c.as, "url")).to eq(:unsafe)
   end
@@ -67,7 +67,7 @@ describe CustomField do
   it "should return a safe list of types for the 'as' select options" do
     { "email"   => %w[check_boxes text string email url tel select radio_buttons],
       "integer" => %w[integer float] }.each do |type, expected_arr|
-      c = FactoryGirl.build(:custom_field, as: type)
+      c = build(:custom_field, as: type)
       opts = c.available_as
       expect(opts.map(&:first)).to match_array(expected_arr)
     end
@@ -81,12 +81,12 @@ describe CustomField do
     expect(Contact).to receive(:reset_column_information).twice
     expect(Contact).to receive(:serialize_custom_fields!).twice
 
-    field_group = FactoryGirl.create(:field_group, klass_name: "Contact")
-    c = FactoryGirl.create(:custom_field,
-                           label: "Test Field",
-                           name: nil,
-                           as: "email",
-                           field_group: field_group)
+    field_group = create(:field_group, klass_name: "Contact")
+    c = create(:custom_field,
+               label: "Test Field",
+               name: nil,
+               as: "email",
+               field_group: field_group)
     c.as = "text"
     c.save
   end
@@ -102,7 +102,7 @@ describe CustomField do
       expect(Contact).to receive(:reset_column_information)
       expect(Contact).to receive(:serialize_custom_fields!)
 
-      contact = FactoryGirl.build(:contact)
+      contact = build(:contact)
       expect(contact.cf_another_new_field).to eq(nil)
     end
   end

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