fat_free_crm 0.18.2 → 0.19.0

data/spec/controllers/comments_controller_spec.rb

@@ -25,12 +25,12 @@ describe CommentsController do
         end
 
         it "should redirect to the asset landing page if the asset is found" do
-          get :index, params: { :"#{asset}_id" => @asset.id }
+          get :index, params: { "#{asset}_id": @asset.id }
           expect(response).to redirect_to(controller: asset.to_s.pluralize, action: :show, id: @asset.id)
         end
 
         it "should redirect to root url with warning if the asset is not found" do
-          get :index, params: { :"#{asset}_id" => @asset.id + 42 }
+          get :index, params: { "#{asset}_id": @asset.id + 42 }
           expect(flash[:warning]).not_to eq(nil)
           expect(response).to redirect_to(root_path)
         end
@@ -44,12 +44,12 @@ describe CommentsController do
         end
 
         it "should render all comments as JSON if the asset is found found" do
-          get :index, params: { :"#{asset}_id" => @asset.id }
+          get :index, params: { "#{asset}_id": @asset.id }
           expect(response.body).to eq(assigns[:comments].to_json)
         end
 
         it "JSON: should return 404 (Not Found) JSON error if the asset is not found" do
-          get :index, params: { :"#{asset}_id" => @asset.id + 42 }
+          get :index, params: { "#{asset}_id": @asset.id + 42 }
           expect(flash[:warning]).not_to eq(nil)
           expect(response.code).to eq("404")
         end
@@ -63,12 +63,12 @@ describe CommentsController do
         end
 
         it "should render all comments as XML if the asset is found found" do
-          get :index, params: { :"#{asset}_id" => @asset.id }
+          get :index, params: { "#{asset}_id": @asset.id }
           expect(response.body).to eq(assigns[:comments].to_xml)
         end
 
         it "XML: should return 404 (Not Found) XML error if the asset is not found" do
-          get :index, params: { :"#{asset}_id" => @asset.id + 42 }
+          get :index, params: { "#{asset}_id": @asset.id + 42 }
           expect(flash[:warning]).not_to eq(nil)
           expect(response.code).to eq("404")
         end

data/spec/controllers/entities/campaigns_controller_spec.rb

@@ -370,7 +370,7 @@ describe CampaignsController do
 
       it "should update campaign permissions when sharing with specific users" do
         @campaign = create(:campaign, id: 42, access: "Public")
-        he  = create(:user, id: 7)
+        he = create(:user, id: 7)
         she = create(:user, id: 8)
 
         put :update, params: { id: 42, campaign: { name: "Hello", access: "Shared", user_ids: %w[7 8] } }, xhr: true

data/spec/controllers/entities/contacts_controller_spec.rb

@@ -334,9 +334,10 @@ describe ContactsController do
         @contact = build(:contact, first_name: "Billy", last_name: "Bones")
         allow(Contact).to receive(:new).and_return(@contact)
 
-        post :create, params: { contact: { first_name: "Billy", last_name: "Bones" }, account: { name: "Hello world" } }, xhr: true
+        post :create, params: { contact: { first_name: "Billy", last_name: "Bones" }, account: { id: "", name: "Hello world" } }, xhr: true
         expect(assigns(:contact)).to eq(@contact)
         expect(assigns(:contact).reload.account.name).to eq("Hello world")
+        expect(assigns(:contact).account.user).to eq(assigns(:contact).user)
         expect(response).to render_template("contacts/create")
       end
 

data/spec/controllers/entities/leads_controller_spec.rb

@@ -465,7 +465,7 @@ describe LeadsController do
 
       it "should update shared permissions for the lead" do
         @lead = create(:lead, user: current_user)
-        he  = create(:user, id: 7)
+        he = create(:user, id: 7)
         she = create(:user, id: 8)
 
         put :update, params: { id: @lead.id, lead: { access: "Shared", user_ids: %w[7 8] } }, xhr: true
@@ -995,7 +995,7 @@ describe LeadsController do
       @leads = [create(:lead, user: current_user, status: "new")]
       post :filter, params: { status: "new" }, xhr: true
       expect(assigns[:leads]).to eq(@leads)
-      expect(response).to be_a_success
+      expect(response).to be_successful
       expect(response).to render_template("leads/index")
     end
 

data/spec/controllers/entities/opportunities_controller_spec.rb

@@ -890,7 +890,7 @@ describe OpportunitiesController do
       get :filter, params: { stage: "prospecting" }, xhr: true
       expect(assigns(:opportunities)).to eq(@opportunities)
       expect(assigns[:stage]).to eq(@stage)
-      expect(response).to be_a_success
+      expect(response).to be_successful
       expect(response).to render_template("opportunities/index")
     end
 

data/spec/controllers/entities_controller_spec.rb

@@ -19,6 +19,11 @@ describe EntitiesController do
       expect(controller.send(:parse_query_and_tags, str)).to eq(['', 'test'])
     end
 
+    it 'should parse #multiword tags' do
+      str = "#multiword tag#"
+      expect(controller.send(:parse_query_and_tags, str)).to eq(['', 'multiword tag'])
+    end
+
     it "should parse no tags" do
       str = "test query"
       expect(controller.send(:parse_query_and_tags, str)).to eq(['test query', ''])

data/spec/controllers/home_controller_spec.rb

@@ -23,7 +23,7 @@ describe HomeController do
     end
 
     it "should not include views in the list of activities" do
-      create(:version, item: create(:account, user: @current_user), event: "view")
+      create(:version, item: create(:account, user: current_user), event: "view")
       expect(controller).to receive(:get_activities).once.and_return([])
 
       get :index
@@ -158,14 +158,14 @@ describe HomeController do
 
     it "should find a user by email" do
       allow(@cur_user).to receive(:pref).and_return(activity_user: 'billy@example.com')
-      controller.instance_variable_set(:@current_user, @cur_user)
+      allow(controller).to receive(:current_user).and_return(@cur_user)
       expect(User).to receive(:where).with(email: 'billy@example.com').and_return([@user])
       expect(controller.send(:activity_user)).to eq(1)
     end
 
     it "should find a user by first name or last name" do
       allow(@cur_user).to receive(:pref).and_return(activity_user: 'Billy')
-      controller.instance_variable_set(:@current_user, @cur_user)
+      allow(controller).to receive(:current_user).and_return(@cur_user)
       expect(User).to receive(:where).with(first_name: 'Billy').and_return([@user])
       expect(User).to receive(:where).with(last_name: 'Billy').and_return([@user])
       expect(controller.send(:activity_user)).to eq(1)
@@ -173,7 +173,7 @@ describe HomeController do
 
     it "should find a user by first name and last name" do
       allow(@cur_user).to receive(:pref).and_return(activity_user: 'Billy Elliot')
-      controller.instance_variable_set(:@current_user, @cur_user)
+      allow(controller).to receive(:current_user).and_return(@cur_user)
       expect(User).to receive(:where).with(first_name: 'Billy', last_name: "Elliot").and_return([@user])
       expect(User).to receive(:where).with(first_name: 'Elliot', last_name: "Billy").and_return([@user])
       expect(controller.send(:activity_user)).to eq(1)
@@ -181,7 +181,7 @@ describe HomeController do
 
     it "should return nil when 'all_users' is specified" do
       allow(@cur_user).to receive(:pref).and_return(activity_user: 'all_users')
-      controller.instance_variable_set(:@current_user, @cur_user)
+      allow(controller).to receive(:current_user).and_return(@cur_user)
       expect(User).not_to receive(:where)
       expect(controller.send(:activity_user)).to eq(nil)
     end

data/spec/controllers/tasks_controller_spec.rb

@@ -24,7 +24,7 @@ describe TasksController do
       end
       hash[due] << case view
                    when "pending"
-                     create(:task, user: user, bucket: due.to_s)
+                     create(:task, user: user, bucket: due.to_s, name: 'Example task')
                    when "assigned"
                      create(:task, user: user, bucket: due.to_s, assigned_to: 1)
                    when "completed"
@@ -83,12 +83,14 @@ describe TasksController do
 
         expect(assigns[:tasks].keys.map(&:to_sym) - @tasks.keys).to eq([])
         expect(assigns[:tasks].values.flatten - @tasks.values.flatten).to eq([])
-        hash = ActiveSupport::JSON.decode(response.body)
 
+        # TODO: This used to return "task" => {...} mappings, now just returns mappings
+        hash = ActiveSupport::JSON.decode(response.body)
         hash.each_key do |key|
-          hash[key].each do |attr|
-            task = Task.new(attr["task"])
+          hash[key].each do |data|
+            task = Task.new(data)
             expect(task).to be_instance_of(Task)
+            puts task.errors.inspect unless task.valid?
             expect(task.valid?).to eq(true)
           end
         end

data/spec/controllers/users_controller_spec.rb

@@ -50,7 +50,6 @@ describe UsersController do
       it "should render the requested user as JSON" do
         expect(User).to receive(:find).and_return(current_user)
         expect_any_instance_of(User).to receive(:to_json).and_return("generated JSON")
-
         get :show, params: { id: current_user.id }
         expect(response.body).to eq("generated JSON")
       end
@@ -85,32 +84,6 @@ describe UsersController do
     end
   end
 
-  # GET /users/new
-  # GET /users/new.xml                                                     HTML
-  #----------------------------------------------------------------------------
-  describe "responding to GET new" do
-    describe "if user is allowed to sign up" do
-      it "should expose a new user as @user and render [new] template" do
-        expect(User).to receive(:can_signup?).and_return(true)
-        @user = build(:user)
-        allow(User).to receive(:new).and_return(@user)
-
-        get :new
-        expect(assigns[:user]).to eq(@user)
-        expect(response).to render_template("users/new")
-      end
-    end
-
-    describe "if user is not allowed to sign up" do
-      it "should redirect to login_path" do
-        expect(User).to receive(:can_signup?).and_return(false)
-
-        get :new
-        expect(response).to redirect_to(login_path)
-      end
-    end
-  end
-
   # GET /users/1/edit                                                      AJAX
   #----------------------------------------------------------------------------
   describe "responding to GET edit" do
@@ -138,50 +111,6 @@ describe UsersController do
     end
   end
 
-  # POST /users
-  # POST /users.xml                                                        HTML
-  #----------------------------------------------------------------------------
-  describe "responding to POST create" do
-    describe "with valid params" do
-      before(:each) do
-        @username = "none"
-        @email = @username + "@example.com"
-        @password = "secret"
-        @user = build(:user, username: @username, email: @email)
-        allow(User).to receive(:new).and_return(@user)
-      end
-
-      it "exposes a newly created user as @user and redirect to profile page" do
-        login_admin
-        post :create, params: { user: { username: @username, email: @email, password: @password, password_confirmation: @password } }
-        expect(assigns[:user]).to eq(@user)
-        expect(flash[:notice]).to match(/welcome/)
-        expect(response).to redirect_to(profile_path)
-      end
-
-      it "should redirect to login page if user signup needs approval" do
-        allow(Setting).to receive(:user_signup).and_return(:needs_approval)
-
-        post :create, params: { user: { username: @username, email: @email, password: @password, password_confirmation: @password } }
-        expect(assigns[:user]).to eq(@user)
-        expect(flash[:notice]).to match(/approval/)
-        expect(response).to redirect_to(login_path)
-      end
-    end
-
-    describe "with invalid params" do
-      it "assigns a newly created but unsaved user as @user and renders [new] template" do
-        login_admin
-        @user = build(:user, username: "", email: "")
-        allow(User).to receive(:new).and_return(@user)
-
-        post :create, params: { user: {} }
-        expect(assigns[:user]).to eq(@user)
-        expect(response).to render_template("users/new")
-      end
-    end
-  end
-
   # PUT /users/1
   # PUT /users/1.xml                                                       AJAX
   #----------------------------------------------------------------------------
@@ -312,52 +241,53 @@ describe UsersController do
   #----------------------------------------------------------------------------
   describe "responding to PUT change_password" do
     before(:each) do
-      login
-      allow(User).to receive(:find).and_return(current_user)
-      allow(@current_user_session).to receive(:unauthorized_record=).and_return(current_user)
-      allow(@current_user_session).to receive(:save).and_return(current_user)
-      @user = current_user
-      @new_password = "secret?!"
+      @old_password = 'foobar123'
+      @user = FactoryBot.create(:user, password: @old_password, password_confirmation: @old_password)
+      perform_login(@user)
+      @old_encrypted_password = @user.encrypted_password
+      @new_password = 'secret?!'
     end
 
     it "should set new user password" do
-      put :change_password, params: { id: @user.id, current_password: @user.password, user: { password: @new_password, password_confirmation: @new_password } }, xhr: true
-      expect(assigns[:user]).to eq(current_user)
-      expect(current_user.password).to eq(@new_password)
-      expect(current_user.errors).to be_empty
-      expect(flash[:notice]).not_to eq(nil)
+      put :change_password, params: { id: @user.id, current_password: @old_password, user: { password: @new_password, password_confirmation: @new_password } }, xhr: true
+      expect(assigns[:user]).to eq(@user)
+      expect(assigns[:user].password).to eq('secret?!')
+      expect(assigns[:user].errors).to be_empty
+      expect(assigns[:user].reload.encrypted_password).to_not eq(@old_encrypted_password) # password change
       expect(response).to render_template("users/change_password")
     end
 
-    it "should allow to change password if current password is blank" do
-      @user.password_hash = nil
+    it "should not allow to change password if current password is blank" do
+      current_user.encrypted_password = nil
       put :change_password, params: { id: @user.id, current_password: "", user: { password: @new_password, password_confirmation: @new_password } }, xhr: true
-      expect(current_user.password).to eq(@new_password)
-      expect(current_user.errors).to be_empty
-      expect(flash[:notice]).not_to eq(nil)
+      expect(assigns[:user].password).to eq(nil)
+      expect(assigns[:user].errors.size).to eq(1) # .error_on(:current_password)
+      expect(assigns[:user].reload.encrypted_password).to eq(@old_encrypted_password) # password stays the same
       expect(response).to render_template("users/change_password")
     end
 
     it "should not change user password if password field is blank" do
-      put :change_password, params: { id: @user.id, current_password: @user.password, user: { password: "", password_confirmation: "" } }, xhr: true
+      put :change_password, params: { id: @user.id, current_password: @old_password, user: { password: "", password_confirmation: "" } }, xhr: true
       expect(assigns[:user]).to eq(current_user)
-      expect(current_user.password).to eq(@user.password) # password stays the same
-      expect(current_user.errors).to be_empty # no errors
-      expect(flash[:notice]).not_to eq(nil)
+      expect(assigns[:user].password).to eq(nil)
+      expect(assigns[:user].errors).to be_empty # no errors
+      expect(assigns[:user].reload.encrypted_password).to eq(@old_encrypted_password) # password stays the same
       expect(response).to render_template("users/change_password")
     end
 
     it "should require valid current password" do
       put :change_password, params: { id: @user.id, current_password: "what?!", user: { password: @new_password, password_confirmation: @new_password } }, xhr: true
-      expect(current_user.password).to eq(@user.password) # password stays the same
-      expect(current_user.errors.size).to eq(1) # .error_on(:current_password)
+      expect(assigns[:user].password).to eq(nil)
+      expect(assigns[:user].errors.size).to eq(1) # .error_on(:current_password)
+      expect(assigns[:user].reload.encrypted_password).to eq(@old_encrypted_password) # password stays the same
       expect(response).to render_template("users/change_password")
     end
 
     it "should require new password and password confirmation to match" do
-      put :change_password, params: { id: @user.id, current_password: @user.password, user: { password: @new_password, password_confirmation: "none" } }, xhr: true
-      expect(current_user.password).to eq(@user.password) # password stays the same
-      expect(current_user.errors.size).to eq(1) # .error_on(:current_password)
+      put :change_password, params: { id: @user.id, current_password: @old_password, user: { password: @new_password, password_confirmation: "none" } }, xhr: true
+      expect(assigns[:user].password).to eq('secret?!')
+      expect(assigns[:user].errors.size).to eq(1) # .error_on(:current_password)
+      expect(assigns[:user].reload.encrypted_password).to eq(@old_encrypted_password) # password stays the same
       expect(response).to render_template("users/change_password")
     end
   end
@@ -368,14 +298,14 @@ describe UsersController do
   describe "responding to GET opportunities_overview" do
     before(:each) do
       login
-      @user = @current_user
+      @user = current_user
       @user.update_attributes(first_name: "Apple", last_name: "Boy")
     end
 
     it "should assign @users_with_opportunities" do
       create(:opportunity, stage: "prospecting", assignee: @user)
       get :opportunities_overview, xhr: true
-      expect(assigns[:users_with_opportunities]).to eq([@current_user])
+      expect(assigns[:users_with_opportunities]).to eq([@user])
     end
 
     it "@users_with_opportunities should be ordered by name" do

data/spec/factories/account_factories.rb

@@ -8,16 +8,16 @@
 FactoryBot.define do
   factory :account do
     user
-    assigned_to nil
+    assigned_to         { nil }
     name                { FFaker::Company.name + rand(100).to_s }
-    access "Public"
+    access              { "Public" }
     website             { FactoryBot.generate(:website) }
     email               { FFaker::Internet.email }
     toll_free_phone     { FFaker::PhoneNumber.phone_number }
     phone               { FFaker::PhoneNumber.phone_number }
     fax                 { FFaker::PhoneNumber.phone_number }
     background_info     { FFaker::Lorem.paragraph[0, 255] }
-    deleted_at nil
+    deleted_at          { nil }
     updated_at          { FactoryBot.generate(:time) }
     created_at          { FactoryBot.generate(:time) }
   end
@@ -25,7 +25,7 @@ FactoryBot.define do
   factory :account_contact do
     account
     contact
-    deleted_at nil
+    deleted_at          { nil }
     updated_at          { FactoryBot.generate(:time) }
     created_at          { FactoryBot.generate(:time) }
   end
@@ -33,7 +33,7 @@ FactoryBot.define do
   factory :account_opportunity do
     account
     opportunity
-    deleted_at nil
+    deleted_at          { nil }
     updated_at          { FactoryBot.generate(:time) }
     created_at          { FactoryBot.generate(:time) }
   end

data/spec/factories/campaign_factories.rb

@@ -9,8 +9,8 @@ FactoryBot.define do
   factory :campaign do
     user
     name                { FFaker::Lorem.sentence[0, 64] }
-    assigned_to nil
-    access "Public"
+    assigned_to         { nil }
+    access              { "Public" }
     status              { %w[planned started completed planned started completed on_hold called_off].sample }
     budget              { rand(500) }
     target_leads        { rand(200) }
@@ -23,7 +23,7 @@ FactoryBot.define do
     starts_on           { FactoryBot.generate(:date) }
     objectives          { FFaker::Lorem.paragraph[0, 255] }
     background_info     { FFaker::Lorem.paragraph[0, 255] }
-    deleted_at nil
+    deleted_at          { nil }
     updated_at          { FactoryBot.generate(:time) }
     created_at          { FactoryBot.generate(:time) }
   end

data/spec/factories/contact_factories.rb

@@ -9,11 +9,11 @@ FactoryBot.define do
   factory :contact do
     user
     lead
-    assigned_to nil
-    reports_to nil
+    assigned_to         { nil }
+    reports_to          { nil }
     first_name          { FFaker::Name.first_name }
     last_name           { FFaker::Name.last_name }
-    access "Public"
+    access              { "Public" }
     title               { FactoryBot.generate(:title) }
     department          { FFaker::Name.name + " Dept." }
     source              { %w[campaign cold_call conference online referral self web word_of_mouth other].sample }
@@ -26,10 +26,10 @@ FactoryBot.define do
     facebook            { FactoryBot.generate(:website) }
     linkedin            { FactoryBot.generate(:website) }
     twitter             { FactoryBot.generate(:website) }
-    do_not_call false
-    born_on "1992-10-10"
+    do_not_call         { false }
+    born_on             { "1992-10-10" }
     background_info     { FFaker::Lorem.paragraph[0, 255] }
-    deleted_at nil
+    deleted_at          { nil }
     updated_at          { FactoryBot.generate(:time) }
     created_at          { FactoryBot.generate(:time) }
   end
@@ -37,8 +37,8 @@ FactoryBot.define do
   factory :contact_opportunity do
     contact
     opportunity
-    role "foo"
-    deleted_at nil
+    role                { "foo" }
+    deleted_at          { nil }
     updated_at          { FactoryBot.generate(:time) }
     created_at          { FactoryBot.generate(:time) }
   end