fat_free_crm 0.20.0 → 0.21.0

data/spec/models/polymorphic/version_spec.rb

@@ -1,241 +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
-#------------------------------------------------------------------------------
-# == Schema Information
-#
-# Table name: versions
-#
-#  id           :integer         not null, primary key
-#  user_id      :integer
-#  item_id   :integer
-#  item_type :string(255)
-#  event       :string(32)      default("create")
-#  info         :string(255)     default("")
-#  private      :boolean         default(FALSE)
-#  created_at   :datetime
-#  updated_at   :datetime
-#
-
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe Version, versioning: true do
-  let(:current_user) { create(:user) }
-  before { PaperTrail.request.whodunnit = current_user.id.to_s }
-
-  it "should create a new instance given valid attributes" do
-    create(:version, whodunnit: PaperTrail.request.whodunnit, item: create(:lead))
-  end
-
-  describe "with multiple version records" do
-    before do
-      @lead = create(:lead)
-
-      %w[create destroy update view].each do |event|
-        create(:version, event: event, item: @lead, whodunnit: PaperTrail.request.whodunnit)
-        create(:version, event: event, item: @lead, whodunnit: "1")
-      end
-    end
-
-    it "should not include view events" do
-      @versions = Version.for(current_user).exclude_events(:view)
-      expect(@versions.pluck(:event).sort).not_to include('view')
-    end
-
-    it "should exclude create, update and destroy events" do
-      @versions = Version.for(current_user).exclude_events(:create, :update, :destroy)
-      expect(@versions.pluck(:event)).not_to include('create')
-      expect(@versions.pluck(:event)).not_to include('update')
-      expect(@versions.pluck(:event)).not_to include('destroy')
-    end
-
-    it "should include only destroy events" do
-      @versions = Version.for(current_user).include_events(:destroy)
-      expect(@versions.pluck(:event).uniq).to eq(['destroy'])
-    end
-
-    it "should include create and update events" do
-      @versions = Version.for(current_user).include_events(:create, :update)
-      expect(@versions.pluck(:event).uniq.sort).to eq(%w[create update])
-    end
-
-    it "should select all versions for a given user" do
-      @versions = Version.for(current_user)
-      expect(@versions.map(&:whodunnit).uniq).to eq([current_user.id.to_s])
-    end
-  end
-
-  %w[account campaign contact lead opportunity task].each do |item|
-    describe "Create, update, and delete (#{item})" do
-      before :each do
-        @item = create(item.to_sym, user: current_user)
-        @conditions = { item_id: @item.id, item_type: @item.class.name, whodunnit: PaperTrail.request.whodunnit }
-      end
-
-      it "should add a version when creating new #{item}" do
-        @version = Version.where(@conditions.merge(event: 'create')).first
-        expect(@version).not_to eq(nil)
-      end
-
-      it "should add a version when updating existing #{item}" do
-        if @item.respond_to?(:full_name)
-          @item.update(first_name: "Billy", last_name: "Bones")
-        else
-          @item.update(name: "Billy Bones")
-        end
-        @version = Version.where(@conditions.merge(event: 'update')).first
-
-        expect(@version).not_to eq(nil)
-      end
-
-      it "should add a version when deleting #{item}" do
-        @item.destroy
-        @version = Version.where(@conditions.merge(event: 'destroy')).first
-
-        expect(@version).not_to eq(nil)
-      end
-
-      it "should add a version when commenting on a #{item}" do
-        @comment = create(:comment, commentable: @item, user: current_user)
-
-        @version = Version.where(related_id: @item.id, related_type: @item.class.name, whodunnit: PaperTrail.request.whodunnit, event: 'create').first
-        expect(@version).not_to eq(nil)
-      end
-    end
-  end
-
-  describe "Recently viewed items (task)" do
-    before do
-      @task = create(:task)
-      @conditions = { item_id: @task.id, item_type: @task.class.name }
-    end
-
-    it "creating a new task should not add it to recently viewed items list" do
-      versions = Version.where(@conditions)
-      expect(versions.pluck(:event)).to include('create') # but not view
-    end
-
-    it "updating a new task should not add it to recently viewed items list" do
-      @task.update(name: 'New Name')
-
-      versions = Version.where(@conditions)
-      expect(versions.pluck(:event).sort).to eq(%w[create update]) # but not view
-    end
-  end
-
-  describe "Action refinements for task updates" do
-    before do
-      @task = create(:task, user: current_user)
-      @conditions = { item_id: @task.id, item_type: @task.class.name, whodunnit: PaperTrail.request.whodunnit }
-    end
-
-    it "should create 'completed' task event" do
-      @task.update(completed_at: 1.second.ago)
-
-      versions = Version.where(@conditions)
-      expect(versions.pluck(:event)).to include('complete')
-    end
-
-    it "should create 'reassigned' task event" do
-      @task.update(assigned_to: current_user.id + 1)
-
-      versions = Version.where(@conditions)
-      expect(versions.pluck(:event)).to include('reassign')
-    end
-
-    it "should create 'rescheduled' task event" do
-      @task.update(bucket: "due_tomorrow") # FactoryBot creates :due_asap task
-
-      versions = Version.where(@conditions)
-      expect(versions.pluck(:event)).to include('reschedule')
-    end
-  end
-
-  describe "Rejecting a lead" do
-    before do
-      @lead = create(:lead, user: current_user, status: "new")
-      @conditions = { item_id: @lead.id, item_type: @lead.class.name, whodunnit: PaperTrail.request.whodunnit }
-    end
-
-    it "should create 'rejected' lead event" do
-      @lead.update(status: "rejected")
-
-      versions = Version.where(@conditions)
-      expect(versions.pluck(:event)).to include('reject')
-    end
-  end
-
-  describe "Permissions" do
-    before do
-      @user = create(:user)
-      Version.delete_all
-    end
-
-    it "should not show the create/update versions if the item is private" do
-      @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)
-      expect(versions.pluck(:event).sort).to eq(%w[create update])
-
-      visible_versions = Version.visible_to(@user)
-      expect(visible_versions).to eq([])
-    end
-
-    it "should not show the destroy version if the item is private" do
-      @item = create(:account, user: current_user, access: "Private")
-      @item.destroy
-
-      versions = Version.where(item_id: @item.id, item_type: @item.class.name)
-      expect(versions.pluck(:event).sort).to eq(%w[create destroy])
-
-      visible_versions = Version.visible_to(@user)
-      expect(visible_versions).to eq([])
-    end
-
-    it "should not show create/update versions if the item was not shared with the user" do
-      @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)
-      expect(versions.pluck(:event).sort).to eq(%w[create update])
-
-      visible_versions = Version.visible_to(@user)
-      expect(visible_versions).to eq([])
-    end
-
-    it "should not show the destroy version if the item was not shared with the user" do
-      @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)
-      expect(versions.pluck(:event).sort).to eq(%w[create destroy])
-
-      visible_versions = Version.visible_to(@user)
-      expect(visible_versions).to eq([])
-    end
-
-    it "should show create/update versions if the item was shared with the user" do
-      @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)
-      expect(versions.pluck(:event).sort).to eq(%w[create update])
-
-      visible_versions = Version.visible_to(@user)
-      expect(visible_versions.map(&:event).sort).to eq(%w[create update])
-    end
-  end
-end

data/spec/models/setting_spec.rb

@@ -1,77 +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
-#------------------------------------------------------------------------------
-# == Schema Information
-#
-# Table name: settings
-#
-#  id            :integer         not null, primary key
-#  name          :string(32)      default(""), not null
-#  value         :text
-#  created_at    :datetime
-#  updated_at    :datetime
-#
-
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe Setting do
-  it "should create a new instance given valid attributes" do
-    Setting.create!(name: "name", value: "value")
-  end
-
-  it "should find existing setting by its name using [] or method notations, and cache settings" do
-    @setting = create(:setting, name: "thingymabob", value: "magoody")
-    expect(Setting.cache.key?("thingymabob")).to eq(false)
-    expect(Setting[:thingymabob]).to eq("magoody")
-    expect(Setting.cache.key?("thingymabob")).to eq(true)
-    expect(Setting.thingymabob).to eq("magoody")
-  end
-
-  it "should use value from YAML if setting is missing from database" do
-    @setting = create(:setting, name: "magoody", value: nil)
-    Setting.yaml_settings[:magoody] = "thingymabob"
-    expect(Setting[:magoody]).to eq("thingymabob")
-    expect(Setting.magoody).to eq("thingymabob")
-  end
-
-  it "should save a new value of a setting using []= or method notation" do
-    Setting[:hello] = "world"
-    expect(Setting[:hello]).to eq("world")
-    expect(Setting.hello).to eq("world")
-
-    Setting.world = "hello"
-    expect(Setting.world).to eq("hello")
-    expect(Setting[:world]).to eq("hello")
-  end
-
-  it "should handle false and nil values correctly" do
-    Setting[:hello] = false
-    expect(Setting[:hello]).to eq(false)
-    expect(Setting.hello).to eq(false)
-  end
-
-  describe "#dig" do
-    it "should dig into nested hashes" do
-      Setting[:hello] = { foo: { bar: 3 } }
-      expect(Setting.dig(:hello, :foo, :bar)).to eq(3)
-    end
-
-    it "should dig into nested arrays" do
-      Setting[:hello] = [1, [2, 3]]
-      expect(Setting.dig(:hello, 1, 1)).to eq(3)
-    end
-
-    it "should return nil if nil" do
-      expect(Setting.dig(:foo, :bar)).to eq(nil)
-    end
-
-    it "should return nil if nil" do
-      Setting[:hello] = "world"
-      expect { Setting.dig(:hello, :foo) }.to raise_error(TypeError)
-    end
-  end
-end

data/spec/models/users/abilities/user_ability_spec.rb

@@ -1,70 +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'
-require 'cancan/matchers'
-
-def all_actions
-  %i[index show create update destroy manage]
-end
-
-describe "User abilities" do
-  subject(:ability)  { Ability.new(user) }
-  let(:subject_user) { build :user }
-
-  context "when site manager, I" do
-    let(:user)  { build :user, admin: true }
-    all_actions.each do |do_action|
-      it { is_expected.to be_able_to(do_action, subject_user) }
-    end
-  end
-
-  context "when myself, I" do
-    let(:user) { build :user }
-    let(:subject_user) { user }
-    all_actions.each do |do_action|
-      it { is_expected.to be_able_to(do_action, subject_user) }
-    end
-  end
-
-  context "when another user, I" do
-    let(:user)  { create :user }
-    let(:can)    { [] }
-    let(:cannot) { %i[show create update index destroy manage] }
-    it do
-      can.each do |do_action|
-        is_expected.to be_able_to(do_action, subject_user)
-      end
-    end
-    it do
-      cannot.each do |do_action|
-        is_expected.not_to be_able_to(do_action, subject_user)
-      end
-    end
-  end
-
-  context "when anonymous user, I" do
-    let(:user)  { nil }
-    let(:can)    { [] }
-    let(:cannot) { %i[show create update index destroy manage] }
-    it do
-      can.each do |do_action|
-        is_expected.to be_able_to(do_action, subject_user)
-      end
-    end
-    it do
-      cannot.each do |do_action|
-        is_expected.not_to be_able_to(do_action, subject_user)
-      end
-    end
-
-    it "and signup enabled" do
-      allow(User).to receive(:can_signup?).and_return(true)
-      is_expected.to be_able_to(:create, User)
-    end
-  end
-end

data/spec/models/users/group_spec.rb

@@ -1,11 +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 Group do
-end

data/spec/models/users/permission_spec.rb

@@ -1,58 +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
-#------------------------------------------------------------------------------
-# == Schema Information
-#
-# Table name: permissions
-#
-#  id         :integer         not null, primary key
-#  user_id    :integer
-#  asset_id   :integer
-#  asset_type :string(255)
-#  created_at :datetime
-#  updated_at :datetime
-#
-
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe Permission do
-  before(:each) do
-    @valid_attributes = {
-      user: mock_model(User),
-      asset: mock_model(Account)
-    }
-  end
-
-  it "should create a new instance given valid attributes" do
-    Permission.create!(@valid_attributes)
-  end
-
-  it "should validate with group_ids" do
-    p = Permission.new group_id: 1
-    expect(p).to be_valid
-  end
-
-  it "should validate with user_ids" do
-    p = Permission.new user_id: 2
-    expect(p).to be_valid
-  end
-
-  it "should validate not allow group_ids or user_ids to be blank" do
-    p = Permission.new
-    expect(p).not_to be_valid
-    expect(p.errors['user_id']).to eq(["can't be blank"])
-    expect(p.errors['group_id']).to eq(["can't be blank"])
-  end
-
-  it 'should not allow duplicate records with (user_id, group_id, asset_type, asset_ids) the same' do
-    permission1 = Permission.create(user_id: 1, group_id: 1, asset_id: 1, asset_type: 'UserWithPermission')
-    permission2 = Permission.new(user_id: 1, group_id: 1, asset_id: 1, asset_type: 'UserWithPermission')
-
-    expect(permission1).to be_valid
-    expect(permission2).not_to be_valid
-  end
-end

data/spec/models/users/preference_spec.rb

@@ -1,71 +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
-#------------------------------------------------------------------------------
-# == Schema Information
-#
-# Table name: preferences
-#
-#  id         :integer         not null, primary key
-#  user_id    :integer
-#  name       :string(32)      default(""), not null
-#  value      :text
-#  created_at :datetime
-#  updated_at :datetime
-#
-
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe Preference do
-  before(:each) do
-    @user = create(:user)
-    @magoody = Base64.encode64("magoody".to_json)
-  end
-
-  it "should create a new instance given valid attributes" do
-    Preference.create!(user: @user, name: "name", value: "value")
-  end
-
-  describe "get user preference" do
-    it "should find and decode existing user preference by its name" do
-      @preference = create(:preference, user: @user, name: "thingymabob", value: @magoody)
-      expect(@user.preference[:thingymabob]).to eq("magoody")
-      expect(@user.preference["thingymabob"]).to eq("magoody")
-    end
-
-    it "should return nil if user preference doesn't exist" do
-      expect(@user.preference[:cool]).to eq(nil)
-    end
-
-    it "should return correct user_id" do
-      @preference = create(:preference, user: @user, name: "thingymabob", value: @magoody)
-      expect(@user.preference[:user_id]).to eq(@user.id)
-    end
-
-    it "should disregard other user's preference with the same name" do
-      @preference = create(:preference, user: create(:user), name: "thingymabob", value: @magoody)
-      expect(@user.preference[:thingymabob]).to eq(nil)
-    end
-
-    it "should not fail is user is nil" do
-      @preference = create(:preference, user: nil, name: "thingymabob", value: @magoody)
-      expect(@preference[:thingymabob]).to eq(nil)
-    end
-  end
-
-  describe "set user preference" do
-    it "should create new user preference" do
-      @user.preference[:hello] = "magoody"
-      expect(@user.reload.preference[:hello]).to eq("magoody")
-    end
-
-    it "should update existing user preference" do
-      @preference = create(:preference, user: @user, name: "thingymabob", value: @magoody)
-      @user.preference[:thingymabob] = "thingy"
-      expect(@user.reload.preference[:thingymabob]).to eq("thingy")
-    end
-  end
-end