fat_free_crm 0.20.1 → 0.22.0

data/spec/controllers/users_controller_spec.rb

@@ -1,375 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright (c) 2008-2013 Michael Dvorkin and contributors.
-#
-# Fat Free CRM is freely distributable under the terms of MIT license.
-# See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
-#------------------------------------------------------------------------------
-require 'spec_helper'
-
-describe UsersController do
-  # GET /users/1
-  # GET /users/1.xml                                                       HTML
-  #----------------------------------------------------------------------------
-  describe "responding to GET show" do
-    before(:each) do
-      login
-    end
-
-    it "should render [show] template" do
-      get :show, params: { id: current_user.id }
-      expect(assigns[:user]).to eq(current_user)
-      expect(response).to render_template("users/show")
-    end
-
-    it "should expose current user as @user if no specific user was requested" do
-      get :show
-      expect(assigns[:user]).to eq(current_user)
-      expect(response).to render_template("users/show")
-    end
-
-    it "should show user if admin user" do
-      @user = create(:user)
-      login_admin
-      get :show, params: { id: @user.id }
-      expect(assigns[:user]).to eq(@user)
-      expect(response).to render_template("users/show")
-    end
-
-    it "should not show user if not admin user" do
-      @user = create(:user)
-      get :show, params: { id: @user.id }
-      expect(response).to redirect_to(root_url)
-    end
-
-    describe "with mime type of JSON" do
-      before(:each) do
-        request.env["HTTP_ACCEPT"] = "application/json"
-      end
-
-      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
-
-      it "should render current user as JSON if no specific user was requested" do
-        expect_any_instance_of(User).to receive(:to_json).and_return("generated JSON")
-
-        get :show
-        expect(response.body).to eq("generated JSON")
-      end
-    end
-
-    describe "with mime type of xml" do
-      before(:each) do
-        request.env["HTTP_ACCEPT"] = "application/xml"
-      end
-
-      it "should render the requested user as XML" do
-        expect(User).to receive(:find).and_return(current_user)
-        expect_any_instance_of(User).to receive(:to_xml).and_return("generated XML")
-
-        get :show, params: { id: current_user.id }
-        expect(response.body).to eq("generated XML")
-      end
-
-      it "should render current user as XML if no specific user was requested" do
-        expect_any_instance_of(User).to receive(:to_xml).and_return("generated XML")
-
-        get :show
-        expect(response.body).to eq("generated XML")
-      end
-    end
-  end
-
-  # GET /users/1/edit                                                      AJAX
-  #----------------------------------------------------------------------------
-  describe "responding to GET edit" do
-    it "should expose current user as @user and render [edit] template" do
-      login
-      @user = current_user
-      get :edit, params: { id: @user.id }, xhr: true
-      expect(assigns[:user]).to eq(current_user)
-      expect(response).to render_template("users/edit")
-    end
-
-    it "should not allow current user to edit another user" do
-      @user = create(:user)
-      login
-      get :edit, params: { id: @user.id }, xhr: true
-      expect(response.body).to eql("window.location.reload();")
-    end
-
-    it "should allow admin to edit another user" do
-      login_admin
-      @user = create(:user)
-      get :edit, params: { id: @user.id }, xhr: true
-      expect(assigns[:user]).to eq(@user)
-      expect(response).to render_template("users/edit")
-    end
-  end
-
-  # PUT /users/1
-  # PUT /users/1.xml                                                       AJAX
-  #----------------------------------------------------------------------------
-  describe "responding to PUT update" do
-    before(:each) do
-      login
-      @user = current_user
-    end
-
-    describe "with valid params" do
-      it "should update user information and render [update] template" do
-        put :update, params: { id: @user.id, user: { first_name: "Billy", last_name: "Bones" } }, xhr: true
-        @user.reload
-        expect(@user.first_name).to eq("Billy")
-        expect(@user.last_name).to eq("Bones")
-        expect(assigns[:user]).to eq(@user)
-        expect(response).to render_template("users/update")
-      end
-    end
-    
-    describe "with a email with whitespace" do
-      it "should update the user information and render [update] template" do
-        put :update, params: { id: @user.id, user: { first_name: "Billy", last_name: "Bones", alt_email: " john@email.com " } }, xhr: true
-        @user.reload
-        expect(@user.first_name).to eq("Billy")
-        expect(@user.last_name).to eq("Bones")
-        expect(assigns[:user]).to eq(@user)
-        expect(response).to render_template("users/update")
-        expect(@user.alt_email).to eq("john@email.com")
-      end      
-    end
-
-    describe "with invalid params" do
-      it "should not update the user information and redraw [update] template" do
-        put :update, params: { id: @user.id, user: { first_name: nil } }, xhr: true
-        expect(@user.reload.first_name).to eq(current_user.first_name)
-        expect(assigns[:user]).to eq(@user)
-        expect(response).to render_template("users/update")
-      end
-    end
-  end
-
-  # DELETE /users/1
-  # DELETE /users/1.xml                HTML and AJAX (not directly exposed yet)
-  #----------------------------------------------------------------------------
-  describe "responding to DELETE destroy" do
-    before(:each) do
-      login
-    end
-
-    it "should destroy the requested user" do
-    end
-
-    it "should redirect to the users list" do
-    end
-  end
-
-  # GET /users/1/avatar
-  # GET /users/1/avatar.xml                                                AJAX
-  #----------------------------------------------------------------------------
-  describe "responding to GET avatar" do
-    before(:each) do
-      login
-      @user = current_user
-    end
-
-    it "should expose current user as @user and render [avatar] template" do
-      get :avatar, params: { id: @user.id }, xhr: true
-      expect(assigns[:user]).to eq(current_user)
-      expect(response).to render_template("users/avatar")
-    end
-  end
-
-  # PUT /users/1/upload_avatar
-  # PUT /users/1/upload_avatar.xml                                         AJAX
-  #----------------------------------------------------------------------------
-  describe "responding to PUT update_avatar" do
-    before(:each) do
-      login
-      @user = current_user
-    end
-
-    it "should delete avatar if user chooses to use Gravatar" do
-      @avatar = create(:avatar, user: @user, entity: @user)
-
-      put :upload_avatar, params: { id: @user.id, gravatar: 1 }, xhr: true
-      expect(@user.reload.avatar).to eq(nil)
-      expect(response).to render_template("users/upload_avatar")
-    end
-
-    it "should do nothing if user hasn't specified the avatar file to upload" do
-      @avatar = create(:avatar, user: @user, entity: @user)
-
-      put :upload_avatar, params: { id: @user.id }, xhr: true
-      expect(@user.avatar).to eq(@avatar)
-      expect(response).to render_template("users/upload_avatar")
-    end
-
-    it "should save the user avatar if it was successfully uploaded and resized" do
-      @image = fixture_file_upload('/rails.png', 'image/png')
-
-      put :upload_avatar, params: { id: @user.id, avatar: { image: @image } }, xhr: true
-      expect(@user.avatar).not_to eq(nil)
-      expect(@user.avatar.image_file_size).to eq(@image.size)
-      expect(@user.avatar.image_file_name).to eq(@image.original_filename)
-      expect(@user.avatar.image_content_type).to eq(@image.content_type)
-      expect(response).to render_template("users/upload_avatar")
-    end
-
-    # -------------------------- Fix later --------------------------------
-    #    it "should return errors if the avatar failed to get uploaded and resized" do
-    #      @image = fixture_file_upload("spec/fixtures/rails.png", "image/png")
-    #      @user.stub(:save).and_return(false) # make it fail
-
-    #      put :upload_avatar, :id => @user.id, :avatar => { :image => @image }
-    #      @user.avatar.errors.should_not be_empty
-    #      @user.avatar.should have(1).error # .error_on(:image)
-    #      response.should render_template("users/upload_avatar")
-    #    end
-  end
-
-  # GET /users/1/password
-  # GET /users/1/password.xml                                              AJAX
-  #----------------------------------------------------------------------------
-  describe "responding to GET avatar" do
-    before(:each) do
-      login
-      @user = current_user
-    end
-
-    it "should expose current user as @user and render [pssword] template" do
-      get :password, params: { id: @user.id }, xhr: true
-      expect(assigns[:user]).to eq(current_user)
-      expect(response).to render_template("users/password")
-    end
-  end
-
-  # PUT /users/1/change_password
-  # PUT /users/1/change_password.xml                                       AJAX
-  #----------------------------------------------------------------------------
-  describe "responding to PUT change_password" do
-    before(:each) do
-      @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: @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 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(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: @old_password, user: { password: "", password_confirmation: "" } }, xhr: true
-      expect(assigns[:user]).to eq(current_user)
-      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(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: @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
-
-  # GET /users/opportunities
-  # GET /users/opportunities.xml                                         HTML
-  #----------------------------------------------------------------------------
-  describe "responding to GET opportunities_overview" do
-    before(:each) do
-      login
-      @user = current_user
-      @user.update(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([@user])
-    end
-
-    it "@users_with_opportunities should be ordered by name" do
-      create(:opportunity, stage: "prospecting", assignee: @user)
-
-      user1 = create(:user, first_name: "Zebra", last_name: "Stripes")
-      create(:opportunity, stage: "prospecting", assignee: user1)
-
-      user2 = create(:user, first_name: "Bilbo", last_name: "Magic")
-      create(:opportunity, stage: "prospecting", assignee: user2)
-
-      get :opportunities_overview, xhr: true
-
-      expect(assigns[:users_with_opportunities]).to eq([@user, user2, user1])
-    end
-
-    it "should assign @unassigned_opportunities with only open unassigned opportunities" do
-      @o1 = create(:opportunity, stage: "prospecting", assignee: nil)
-      @o2 = create(:opportunity, stage: "won", assignee: nil)
-      @o3 = create(:opportunity, stage: "prospecting", assignee: nil)
-
-      get :opportunities_overview, xhr: true
-
-      expect(assigns[:unassigned_opportunities]).to include(@o1, @o3)
-      expect(assigns[:unassigned_opportunities]).not_to include(@o2)
-    end
-
-    it "@unassigned_opportunities should be ordered by stage" do
-      @o1 = create(:opportunity, stage: "proposal", assignee: nil)
-      @o2 = create(:opportunity, stage: "prospecting", assignee: nil)
-      @o3 = create(:opportunity, stage: "negotiation", assignee: nil)
-
-      get :opportunities_overview, xhr: true
-
-      expect(assigns[:unassigned_opportunities]).to eq([@o3, @o1, @o2])
-    end
-
-    it "should not include users who have no assigned opportunities" do
-      get :opportunities_overview, xhr: true
-      expect(assigns[:users_with_opportunities]).to eq([])
-    end
-
-    it "should not include users who have no open assigned opportunities" do
-      create(:opportunity, stage: "won", assignee: @user)
-
-      get :opportunities_overview, xhr: true
-      expect(assigns[:users_with_opportunities]).to eq([])
-    end
-
-    it "should render opportunities overview" do
-      get :opportunities_overview, xhr: true
-      expect(response).to render_template("users/opportunities_overview")
-    end
-  end
-end

data/spec/factories/account_factories.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright (c) 2008-2013 Michael Dvorkin and contributors.
-#
-# Fat Free CRM is freely distributable under the terms of MIT license.
-# See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
-#------------------------------------------------------------------------------
-FactoryBot.define do
-  factory :account do
-    user
-    assigned_to         { nil }
-    name                { FFaker::Company.name + rand(100).to_s }
-    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 }
-    updated_at          { FactoryBot.generate(:time) }
-    created_at          { FactoryBot.generate(:time) }
-  end
-
-  factory :account_contact do
-    account
-    contact
-    deleted_at          { nil }
-    updated_at          { FactoryBot.generate(:time) }
-    created_at          { FactoryBot.generate(:time) }
-  end
-
-  factory :account_opportunity do
-    account
-    opportunity
-    deleted_at          { nil }
-    updated_at          { FactoryBot.generate(:time) }
-    created_at          { FactoryBot.generate(:time) }
-  end
-end

data/spec/factories/campaign_factories.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright (c) 2008-2013 Michael Dvorkin and contributors.
-#
-# Fat Free CRM is freely distributable under the terms of MIT license.
-# See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
-#------------------------------------------------------------------------------
-FactoryBot.define do
-  factory :campaign do
-    user
-    name                { FFaker::Lorem.sentence[0, 64] }
-    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) }
-    target_conversion   { rand(20) }
-    target_revenue      { rand(1000) }
-    leads_count         { rand(200) }
-    opportunities_count { rand(20) }
-    revenue             { rand(1000) }
-    ends_on             { FactoryBot.generate(:date) }
-    starts_on           { FactoryBot.generate(:date) }
-    objectives          { FFaker::Lorem.paragraph[0, 255] }
-    background_info     { FFaker::Lorem.paragraph[0, 255] }
-    deleted_at          { nil }
-    updated_at          { FactoryBot.generate(:time) }
-    created_at          { FactoryBot.generate(:time) }
-  end
-end

data/spec/factories/contact_factories.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright (c) 2008-2013 Michael Dvorkin and contributors.
-#
-# Fat Free CRM is freely distributable under the terms of MIT license.
-# See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
-#------------------------------------------------------------------------------
-FactoryBot.define do
-  factory :contact do
-    user
-    lead
-    assigned_to         { nil }
-    reports_to          { nil }
-    first_name          { FFaker::Name.first_name }
-    last_name           { FFaker::Name.last_name }
-    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 }
-    email               { FFaker::Internet.email }
-    alt_email           { FFaker::Internet.email }
-    phone               { FFaker::PhoneNumber.phone_number }
-    mobile              { FFaker::PhoneNumber.phone_number }
-    fax                 { FFaker::PhoneNumber.phone_number }
-    blog                { FactoryBot.generate(:website) }
-    facebook            { FactoryBot.generate(:website) }
-    linkedin            { FactoryBot.generate(:website) }
-    twitter             { FactoryBot.generate(:website) }
-    do_not_call         { false }
-    born_on             { "1992-10-10" }
-    background_info     { FFaker::Lorem.paragraph[0, 255] }
-    deleted_at          { nil }
-    updated_at          { FactoryBot.generate(:time) }
-    created_at          { FactoryBot.generate(:time) }
-  end
-
-  factory :contact_opportunity do
-    contact
-    opportunity
-    role                { "foo" }
-    deleted_at          { nil }
-    updated_at          { FactoryBot.generate(:time) }
-    created_at          { FactoryBot.generate(:time) }
-  end
-end

data/spec/factories/field_factories.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright (c) 2008-2013 Michael Dvorkin and contributors.
-#
-# Fat Free CRM is freely distributable under the terms of MIT license.
-# See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
-#------------------------------------------------------------------------------
-FactoryBot.define do
-  sequence :klass_name do |_x|
-    %w[Contact Account Opportunity Lead Campaign].sample
-  end
-
-  sequence(:field_position) { |x| x }
-
-  sequence :field_label do |x|
-    FFaker::Internet.user_name + x.to_s
-  end
-
-  factory :field_group do
-    klass_name          { FactoryBot.generate(:klass_name) }
-    label               { FactoryBot.generate(:field_label) }
-    tag
-  end
-
-  factory :field do
-    type { "Field" }
-    field_group
-    position            { FactoryBot.generate(:field_position) }
-    label               { FactoryBot.generate(:field_label) }
-    name                { |f| f.label.downcase.gsub(/[^a-z0-9]+/, '_') }
-    as { "string" }
-    minlength           { rand(100) }
-    updated_at          { FactoryBot.generate(:time) }
-    created_at          { FactoryBot.generate(:time) }
-  end
-
-  factory :custom_field do
-    type { "CustomField" }
-  end
-end

data/spec/factories/lead_factories.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright (c) 2008-2013 Michael Dvorkin and contributors.
-#
-# Fat Free CRM is freely distributable under the terms of MIT license.
-# See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
-#------------------------------------------------------------------------------
-FactoryBot.define do
-  factory :lead do
-    user
-    campaign
-    assigned_to         { nil }
-    first_name          { FFaker::Name.first_name }
-    last_name           { FFaker::Name.last_name }
-    access              { "Public" }
-    company             { FFaker::Company.name }
-    title               { FactoryBot.generate(:title) }
-    source              { %w[campaign cold_call conference online referral self web word_of_mouth other].sample }
-    status              { %w[new contacted converted rejected].sample }
-    rating              { 1 }
-    referred_by         { FFaker::Name.name }
-    do_not_call         { false }
-    blog                { FactoryBot.generate(:website) }
-    linkedin            { FactoryBot.generate(:website) }
-    facebook            { FactoryBot.generate(:website) }
-    twitter             { FactoryBot.generate(:website) }
-    email               { FFaker::Internet.email }
-    alt_email           { FFaker::Internet.email }
-    phone               { FFaker::PhoneNumber.phone_number }
-    mobile              { FFaker::PhoneNumber.phone_number }
-    background_info     { FFaker::Lorem.paragraph[0, 255] }
-    deleted_at          { nil }
-    updated_at          { FactoryBot.generate(:time) }
-    created_at          { FactoryBot.generate(:time) }
-  end
-end

data/spec/factories/list_factories.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright (c) 2008-2013 Michael Dvorkin and contributors.
-#
-# Fat Free CRM is freely distributable under the terms of MIT license.
-# See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
-#------------------------------------------------------------------------------
-FactoryBot.define do
-  factory :list do
-    name { "Foo List" }
-    url { "/controller/action" }
-  end
-end

data/spec/factories/opportunity_factories.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright (c) 2008-2013 Michael Dvorkin and contributors.
-#
-# Fat Free CRM is freely distributable under the terms of MIT license.
-# See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
-#------------------------------------------------------------------------------
-FactoryBot.define do
-  sequence :opportunity_status do |_s|
-    %w[prospecting analysis presentation proposal negotiation final_review won lost].sample
-  end
-
-  sequence :opportunity_open_status do |_s|
-    %w[prospecting analysis presentation proposal negotiation final_review].sample
-  end
-
-  factory :opportunity do
-    user
-    campaign
-    account
-    assigned_to         { nil }
-    name                { FFaker::Lorem.sentence[0, 64] }
-    access              { "Public" }
-    source              { %w[campaign cold_call conference online referral self web word_of_mouth other].sample }
-    stage               { FactoryBot.generate(:opportunity_status) }
-    probability         { rand(50) }
-    amount              { rand(1000) }
-    discount            { rand(100) }
-    closes_on           { FactoryBot.generate(:date) }
-    background_info     { FFaker::Lorem.paragraph[0, 255] }
-    deleted_at          { nil }
-    updated_at          { FactoryBot.generate(:time) }
-    created_at          { FactoryBot.generate(:time) }
-  end
-
-  factory :opportunity_in_pipeline, parent: :opportunity do
-    stage               { FactoryBot.generate(:opportunity_open_status) }
-  end
-end

data/spec/factories/sequences.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright (c) 2008-2013 Michael Dvorkin and contributors.
-#
-# Fat Free CRM is freely distributable under the terms of MIT license.
-# See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
-#------------------------------------------------------------------------------
-FactoryBot.define do
-  sequence :address do |_n|
-    FFaker::Address.street_address + " " + FFaker::Address.secondary_address + "\n" + FFaker::Address.city + ", " + FFaker::AddressUS.state_abbr + " " + FFaker::AddressUS.zip_code
-  end
-
-  sequence :username do |n|
-    FFaker::Internet.user_name + n.to_s # make sure it's unique by appending sequence number
-  end
-
-  sequence :website do |_n|
-    "http://www." + FFaker::Internet.domain_name
-  end
-
-  sequence :title do |_n|
-    ["", "Director", "Sales Manager", "Executive Assistant", "Marketing Manager", "Project Manager", "Product Manager", "Engineer"].sample
-  end
-
-  sequence :time do |n|
-    Time.now - n.hours
-  end
-
-  sequence :date do |n|
-    Date.today - n.days
-  end
-end

data/spec/factories/setting_factories.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-# Copyright (c) 2008-2013 Michael Dvorkin and contributors.
-#
-# Fat Free CRM is freely distributable under the terms of MIT license.
-# See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
-#------------------------------------------------------------------------------
-FactoryBot.define do
-  factory :setting do
-    name                { "foo" }
-    value               { nil }
-    updated_at          { FactoryBot.generate(:time) }
-    created_at          { FactoryBot.generate(:time) }
-  end
-end