fat_free_crm 0.20.0 → 0.21.0

data/spec/models/entities/opportunity_spec.rb

@@ -1,299 +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: opportunities
-#
-#  id              :integer         not null, primary key
-#  user_id         :integer
-#  campaign_id     :integer
-#  assigned_to     :integer
-#  name            :string(64)      default(""), not null
-#  access          :string(8)       default("Public")
-#  source          :string(32)
-#  stage           :string(32)
-#  probability     :integer
-#  amount          :decimal(12, 2)
-#  discount        :decimal(12, 2)
-#  closes_on       :date
-#  deleted_at      :datetime
-#  created_at      :datetime
-#  updated_at      :datetime
-#  background_info :string(255)
-#
-
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe Opportunity do
-  it "should create a new instance given valid attributes" do
-    Opportunity.create!(name: "Opportunity", stage: 'analysis')
-  end
-
-  it "should be possible to create opportunity with the same name" do
-    create(:opportunity, name: "Hello")
-    expect { create(:opportunity, name: "Hello") }.to_not raise_error
-  end
-
-  it "have a default stage" do
-    expect(Setting).to receive(:[]).with(:opportunity_default_stage).and_return('default')
-    expect(Opportunity.default_stage).to eql('default')
-  end
-
-  it "have a fallback default stage" do
-    expect(Opportunity.default_stage).to eql('prospecting')
-  end
-
-  describe "Update existing opportunity" do
-    before(:each) do
-      @account = create(:account)
-      @opportunity = create(:opportunity, account: @account)
-    end
-
-    it "should create new account if requested so" do
-      expect do
-        @opportunity.update_with_account_and_permissions(
-          account: { name: "New account" },
-          opportunity: { name: "Hello" }
-        )
-      end.to change(Account, :count).by(1)
-      expect(Account.last.name).to eq("New account")
-      expect(@opportunity.name.gsub(/#\d+ /, '')).to eq("Hello")
-    end
-
-    it "should update the account another account was selected" do
-      @another_account = create(:account)
-      expect do
-        @opportunity.update_with_account_and_permissions(
-          account: { id: @another_account.id },
-          opportunity: { name: "Hello" }
-        )
-      end.not_to change(Account, :count)
-      expect(@opportunity.account).to eq(@another_account)
-      expect(@opportunity.name.gsub(/#\d+ /, '')).to eq("Hello")
-    end
-
-    it "should drop existing Account if [create new account] is blank" do
-      expect do
-        @opportunity.update_with_account_and_permissions(
-          account: { name: "" },
-          opportunity: { name: "Hello" }
-        )
-      end.not_to change(Account, :count)
-      expect(@opportunity.account).to be_nil
-      expect(@opportunity.name.gsub(/#\d+ /, '')).to eq("Hello")
-    end
-
-    it "should drop existing Account if [-- None --] is selected from list of accounts" do
-      expect do
-        @opportunity.update_with_account_and_permissions(
-          account: { id: "" },
-          opportunity: { name: "Hello" }
-        )
-      end.not_to change(Account, :count)
-      expect(@opportunity.account).to be_nil
-      expect(@opportunity.name.gsub(/#\d+ /, '')).to eq("Hello")
-    end
-
-    it "should change account if entered name of another account was found" do
-      @another_account = create(:account, name: "Another name")
-      expect do
-        @opportunity.update_with_account_and_permissions(
-          account: { name: "Another name" },
-          opportunity: { name: "Hello" }
-        )
-      end.not_to change(Account, :count)
-      expect(@opportunity.account).to eq(@another_account)
-      expect(@opportunity.name.gsub(/#\d+ /, '')).to eq("Hello")
-    end
-
-    it "should set the probability to 0% if opportunity has been lost" do
-      opportunity = create(:opportunity, stage: "prospecting", probability: 25)
-      opportunity.update(stage: 'lost')
-      opportunity.reload
-      expect(opportunity.probability).to eq(0)
-    end
-
-    it "should set the probablility to 100% if opportunity has been won" do
-      opportunity = create(:opportunity, stage: "prospecting", probability: 65)
-      opportunity.update(stage: 'won')
-      opportunity.reload
-      expect(opportunity.probability).to eq(100)
-    end
-  end
-
-  describe "Scopes" do
-    it "should find non-closed opportunities" do
-      Opportunity.delete_all
-      @opportunities = [
-        create(:opportunity, stage: "prospecting", amount: 1),
-        create(:opportunity, stage: "analysis", amount: 1),
-        create(:opportunity, stage: "won",      amount: 2),
-        create(:opportunity, stage: "won",      amount: 2),
-        create(:opportunity, stage: "lost",     amount: 3),
-        create(:opportunity, stage: "lost",     amount: 3)
-      ]
-      expect(Opportunity.pipeline.sum(:amount)).to eq(2)
-      expect(Opportunity.won.sum(:amount)).to eq(4)
-      expect(Opportunity.lost.sum(:amount)).to eq(6)
-      expect(Opportunity.sum(:amount)).to eq(12)
-    end
-
-    context "unassigned" do
-      let(:unassigned_opportunity) { create(:opportunity, assignee: nil) }
-      let(:assigned_opportunity) { create(:opportunity, assignee: create(:user)) }
-
-      it "includes unassigned opportunities" do
-        expect(Opportunity.unassigned).to include(unassigned_opportunity)
-      end
-
-      it "does not include opportunities assigned to a user" do
-        expect(Opportunity.unassigned).not_to include(assigned_opportunity)
-      end
-    end
-  end
-
-  describe "Attach" do
-    before do
-      @opportunity = create(:opportunity)
-    end
-
-    it "should return nil when attaching existing asset" do
-      @task = create(:task, asset: @opportunity)
-      @contact = create(:contact)
-      @opportunity.contacts << @contact
-
-      expect(@opportunity.attach!(@task)).to eq(nil)
-      expect(@opportunity.attach!(@contact)).to eq(nil)
-    end
-
-    it "should return non-empty list of attachments when attaching new asset" do
-      @task = create(:task)
-      @contact = create(:contact)
-
-      expect(@opportunity.attach!(@task)).to eq([@task])
-      expect(@opportunity.attach!(@contact)).to eq([@contact])
-    end
-  end
-
-  describe "Discard" do
-    before do
-      @opportunity = create(:opportunity)
-    end
-
-    it "should discard a task" do
-      @task = create(:task, asset: @opportunity)
-      expect(@opportunity.tasks.count).to eq(1)
-
-      @opportunity.discard!(@task)
-      expect(@opportunity.reload.tasks).to eq([])
-      expect(@opportunity.tasks.count).to eq(0)
-    end
-
-    it "should discard an contact" do
-      @contact = create(:contact)
-      @opportunity.contacts << @contact
-      expect(@opportunity.contacts.count).to eq(1)
-
-      @opportunity.discard!(@contact)
-      expect(@opportunity.contacts).to eq([])
-      expect(@opportunity.contacts.count).to eq(0)
-    end
-  end
-
-  describe "Exportable" do
-    describe "assigned opportunity" do
-      let(:opportunity1) { build(:opportunity, user: create(:user), assignee: create(:user)) }
-      let(:opportunity2) { build(:opportunity, 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) { [opportunity1, opportunity2] }
-      end
-    end
-
-    describe "unassigned opportunity" do
-      let(:opportunity1) { build(:opportunity, user: create(:user), assignee: nil) }
-      let(:opportunity2) { build(:opportunity, user: create(:user, first_name: nil, last_name: nil), assignee: nil) }
-      it_should_behave_like("exportable") do
-        let(:exported) { [opportunity1, opportunity2] }
-      end
-    end
-  end
-
-  describe "permissions" do
-    it_should_behave_like Ability, Opportunity
-  end
-
-  describe "scopes" do
-    context "visible_on_dashboard" do
-      before :each do
-        @user = create(:user)
-        @o1 = create(:opportunity_in_pipeline, user: @user, stage: 'prospecting')
-        @o2 = create(:opportunity_in_pipeline, user: @user, assignee: create(:user), stage: 'prospecting')
-        @o3 = create(:opportunity_in_pipeline, user: create(:user), assignee: @user, stage: 'prospecting')
-        @o4 = create(:opportunity_in_pipeline, user: create(:user), assignee: create(:user), stage: 'prospecting')
-        @o5 = create(:opportunity_in_pipeline, user: create(:user), assignee: @user, stage: 'prospecting')
-        @o6 = create(:opportunity, assignee: @user, stage: 'won')
-        @o7 = create(:opportunity, assignee: @user, stage: 'lost')
-      end
-
-      it "should show opportunities which have been created by the user and are unassigned" do
-        expect(Opportunity.visible_on_dashboard(@user)).to include(@o1)
-      end
-
-      it "should show opportunities which are assigned to the user" do
-        expect(Opportunity.visible_on_dashboard(@user)).to include(@o3, @o5)
-      end
-
-      it "should not show opportunities which are not assigned to the user" do
-        expect(Opportunity.visible_on_dashboard(@user)).not_to include(@o4)
-      end
-
-      it "should not show opportunities which are created by the user but assigned" do
-        expect(Opportunity.visible_on_dashboard(@user)).not_to include(@o2)
-      end
-
-      it "does not include won or lost opportunities" do
-        expect(Opportunity.visible_on_dashboard(@user)).not_to include(@o6)
-        expect(Opportunity.visible_on_dashboard(@user)).not_to include(@o7)
-      end
-    end
-
-    context "by_closes_on" do
-      let(:o1) { create(:opportunity, closes_on: 3.days.from_now) }
-      let(:o2) { create(:opportunity, closes_on: 7.days.from_now) }
-      let(:o3) { create(:opportunity, closes_on: 5.days.from_now) }
-
-      it "should show opportunities ordered by closes on" do
-        expect(Opportunity.by_closes_on).to eq([o1, o3, o2])
-      end
-    end
-
-    context "by_amount" do
-      let(:o1) { create(:opportunity, amount:  50_000) }
-      let(:o2) { create(:opportunity, amount:  10_000) }
-      let(:o3) { create(:opportunity, amount: 750_000) }
-
-      it "should show opportunities ordered by amount" do
-        expect(Opportunity.by_amount).to eq([o3, o1, o2])
-      end
-    end
-
-    context "not lost" do
-      let(:o1) { create(:opportunity, stage: 'won') }
-      let(:o2) { create(:opportunity, stage: 'lost') }
-      let(:o3) { create(:opportunity, stage: 'analysis') }
-
-      it "should show opportunities which are not lost" do
-        expect(Opportunity.not_lost).to include(o1, o3)
-      end
-
-      it "should not show opportunities which are lost" do
-        expect(Opportunity.not_lost).not_to include(o2)
-      end
-    end
-  end
-end

data/spec/models/fields/custom_field_date_pair_spec.rb

@@ -1,92 +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 CustomFieldDatePair do
-  describe "render_value" do
-    before(:each) do
-      @from = CustomFieldDatePair.new(name: 'cf_event_from')
-      @to = CustomFieldDatePair.new(name: 'cf_event_to')
-      allow(@from).to receive(:paired_with).and_return(@to)
-      @today = Date.today
-      @today_str = @today.strftime(I18n.t("date.formats.mmddyy"))
-    end
-
-    it "should be from..." do
-      foo = double(cf_event_from: @today, cf_event_to: nil)
-      expect(@from.render_value(foo)).to eq("From #{@today_str}")
-    end
-
-    it "should be until..." do
-      foo = double(cf_event_from: nil, cf_event_to: @today)
-      expect(@from.render_value(foo)).to eq("Until #{@today_str}")
-    end
-
-    it "should be from ... to" do
-      foo = double(cf_event_from: @today, cf_event_to: @today)
-      expect(@from.render_value(foo)).to eq("From #{@today_str} to #{@today_str}")
-    end
-
-    it "should be empty string" do
-      foo = double(cf_event_from: nil, cf_event_to: nil)
-      expect(@from.render_value(foo)).to eq("")
-    end
-  end
-
-  describe "custom_validator" do
-    before(:each) do
-      @from = CustomFieldDatePair.new(name: 'cf_event_from')
-      @to = CustomFieldDatePair.new(name: 'cf_event_to', pair_id: 1)
-      allow(CustomFieldPair).to receive(:find).and_return(@from)
-      @today = Date.today
-      @today_str = @today.strftime(I18n.t("date.formats.mmddyy"))
-    end
-
-    it "when from is nil it should be valid" do
-      foo = double(cf_event_from: nil, cf_event_to: @today)
-      expect(foo).not_to receive(:errors)
-      @to.custom_validator(foo)
-    end
-
-    it "when to is nil it should be valid" do
-      foo = double(cf_event_from: @today, cf_event_to: nil)
-      expect(foo).not_to receive(:errors)
-      @to.custom_validator(foo)
-    end
-
-    it "when from <= to it should be valid" do
-      foo = double(cf_event_from: @today, cf_event_to: @today)
-      expect(foo).not_to receive(:errors)
-      @to.custom_validator(foo)
-    end
-
-    it "when from > to it should not be valid" do
-      foo = double(cf_event_from: @today, cf_event_to: @today - 1.day)
-      err = double(:errors)
-      allow(err).to receive(:add)
-      expect(foo).to receive(:errors).and_return(err)
-      @to.custom_validator(foo)
-    end
-
-    it "should ignore validation when called on from" do
-      foo = double(cf_event_from: @today, cf_event_to: @today - 1.day)
-      expect(foo).not_to receive(:errors)
-      expect(CustomFieldPair).not_to receive(:find)
-      @from.custom_validator(foo)
-    end
-
-    it "should call custom field validation on super class" do
-      from = CustomFieldDatePair.new(name: 'cf_event_from', required: true)
-      foo = double(cf_event_from: nil)
-      err = double(:errors)
-      allow(err).to receive(:add)
-      expect(foo).to receive(:errors).and_return(err)
-      from.custom_validator(foo)
-    end
-  end
-end

data/spec/models/fields/custom_field_pair_spec.rb

@@ -1,76 +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 CustomFieldPair do
-  class CustomFieldFooPair
-  end
-
-  it "should respond to pair" do
-    expect(CustomFieldPair.new).to respond_to(:pair)
-  end
-
-  describe "create_pair" do
-    before(:each) do
-      @field = { 'as' => 'foopair', 'field_group_id' => 1, 'label' => 'Event' }
-      @pair1 = { 'name' => 'pair1' }
-      @pair2 = { 'name' => 'pair2' }
-      @params = { 'field' => @field, 'pair' => { '0' => @pair1, '1' => @pair2 } }
-    end
-
-    it "should create the pair" do
-      params1 = @field.merge(@pair1)
-      foo1 = double(id: 3, required: true, disabled: 'false')
-      expect(CustomFieldFooPair).to receive(:create).with(params1).and_return(foo1)
-      params2 = @field.merge(@pair2).merge('pair_id' => 3, 'required' => true, 'disabled' => 'false')
-      foo2 = double(id: 5)
-      expect(CustomFieldFooPair).to receive(:create).with(params2).and_return(foo2)
-
-      expect(CustomFieldPair.create_pair(@params)).to eq([foo1, foo2])
-    end
-  end
-
-  describe "update_pair" do
-    before(:each) do
-      @field = { 'as' => 'foopair', 'field_group_id' => 1, 'label' => 'Event' }
-      @pair1 = { 'name' => 'pair1' }
-      @pair2 = { 'name' => 'pair2' }
-      @params = { 'id' => '3', 'field' => @field, 'pair' => { '0' => @pair1, '1' => @pair2 } }
-    end
-
-    it "should update the pair" do
-      foo1 = double(required: true, disabled: 'false')
-      expect(foo1).to receive(:update).with(@field.merge(@pair1))
-      foo2 = double
-      expect(foo2).to receive(:update).with(@field.merge(@pair2).merge('required' => true, 'disabled' => 'false'))
-      expect(foo1).to receive(:paired_with).and_return(foo2)
-      expect(CustomFieldPair).to receive(:find).with('3').and_return(foo1)
-
-      expect(CustomFieldPair.update_pair(@params)).to eq([foo1, foo2])
-    end
-  end
-
-  describe "paired_with" do
-    before(:each) do
-      @field1 = CustomFieldDatePair.new(name: 'cf_event_from')
-      @field2 = CustomFieldDatePair.new(name: 'cf_event_to')
-    end
-
-    it "should return the 2nd field" do
-      expect(@field1).to receive(:pair).and_return(@field2)
-      expect(@field1.paired_with).to eq(@field2)
-    end
-
-    it "should return the 1st field" do
-      expect(@field2).to receive(:pair).and_return(nil)
-      expect(@field2).to receive(:id).and_return(1)
-      expect(CustomFieldPair).to receive(:where).with(pair_id: 1).and_return([@field1])
-      expect(@field2.paired_with).to eq(@field1)
-    end
-  end
-end

data/spec/models/fields/custom_field_spec.rb

@@ -1,129 +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: fields
-#
-#  id             :integer         not null, primary key
-#  type           :string(255)
-#  field_group_id :integer
-#  position       :integer
-#  name           :string(64)
-#  label          :string(128)
-#  hint           :string(255)
-#  placeholder    :string(255)
-#  as             :string(32)
-#  collection     :text
-#  disabled       :boolean
-#  required       :boolean
-#  maxlength      :integer
-#  created_at     :datetime
-#  updated_at     :datetime
-#
-
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe CustomField do
-  it "should add a column to the database" do
-    expect(CustomField.connection).to receive(:add_column)
-      .with("contacts", "cf_test_field", 'string', {})
-    expect(Contact).to receive(:reset_column_information)
-    expect(Contact).to receive(:serialize_custom_fields!)
-
-    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 = 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|
-      expect(c.send(:generate_column_name)).to eq(field)
-      allow(Contact).to receive(:column_names).and_return(columns << field)
-    end
-  end
-
-  it "should evaluate the safety of database transitions" do
-    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 = 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
-
-  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 = build(:custom_field, as: type)
-      opts = c.available_as
-      expect(opts.map(&:first)).to match_array(expected_arr)
-    end
-  end
-
-  it "should change a column's type for safe transitions" do
-    expect(CustomField.connection).to receive(:add_column)
-      .with("contacts", "cf_test_field", 'string', {})
-    expect(CustomField.connection).to receive(:change_column)
-      .with("contacts", "cf_test_field", 'text', {})
-    expect(Contact).to receive(:reset_column_information).twice
-    expect(Contact).to receive(:serialize_custom_fields!).twice
-
-    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
-
-  describe "in case a new custom field was added by a different instance" do
-    it "should refresh column info and retry on assignment error" do
-      expect(Contact).to receive(:reset_column_information)
-
-      expect { Contact.new cf_unknown_field: 123 }.to raise_error(ActiveRecord::UnknownAttributeError)
-    end
-
-    it "should refresh column info and retry on attribute error" do
-      expect(Contact).to receive(:reset_column_information)
-      expect(Contact).to receive(:serialize_custom_fields!)
-
-      contact = build(:contact)
-      expect(contact.cf_another_new_field).to eq(nil)
-    end
-  end
-
-  describe "validation" do
-    it "should have errors if custom field is required" do
-      event = CustomField.new(name: 'cf_event', required: true)
-      foo = double(cf_event: nil)
-      err = double(:errors)
-      allow(err).to receive(:add)
-      expect(foo).to receive(:errors).and_return(err)
-      event.custom_validator(foo)
-    end
-
-    it "should have errors if custom field is longer than maxlength" do
-      event = CustomField.new(name: 'cf_event', maxlength: 5)
-      foo = double(cf_event: "This is too long")
-      err = double(:errors)
-      allow(err).to receive(:add)
-      expect(foo).to receive(:errors).and_return(err)
-      event.custom_validator(foo)
-    end
-  end
-end

data/spec/models/fields/field_group_spec.rb

@@ -1,29 +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: field_groups
-#
-#  id         :integer         not null, primary key
-#  name       :string(64)
-#  label      :string(128)
-#  position   :integer
-#  hint       :string(255)
-#  created_at :datetime
-#  updated_at :datetime
-#  tag_id     :integer
-#  klass_name :string(32)
-#
-
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe FieldGroup do
-  it "should have field metadata" do
-    expect(FieldGroup.new).to respond_to(:fields)
-  end
-end

data/spec/models/fields/field_spec.rb

@@ -1,69 +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: fields
-#
-#  id             :integer         not null, primary key
-#  type           :string(255)
-#  field_group_id :integer
-#  position       :integer
-#  name           :string(64)
-#  label          :string(128)
-#  hint           :string(255)
-#  placeholder    :string(255)
-#  as             :string(32)
-#  collection     :text
-#  disabled       :boolean
-#  required       :boolean
-#  minlength      :integer
-#  maxlength      :integer
-#  created_at     :datetime
-#  updated_at     :datetime
-#
-
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-
-describe Field do
-  it "should create a new instance given valid attributes" do
-    Field.create!(
-      name:      'skype_address',
-      label:     'Skype address',
-      as:        'string',
-      minlength: 12,
-      maxlength: 220,
-      position:  10
-    )
-  end
-
-  it "should return a list of field types" do
-    expect(Field.field_types['string']).to eq('klass' => 'CustomField', 'type' => 'string')
-  end
-
-  it "should return a hash of input options" do
-    expect(Field.new.input_options).to be_a(Hash)
-  end
-
-  it "should be able to display a empty multi_select value" do
-    field = Field.new(
-      label: "Availability",
-      name:  "availability"
-    )
-    object = double('Object')
-
-    #  as  |  value  |  expected
-    [["check_boxes", [1, 2, 3], "1, 2<br />3"],
-     %w[checkbox 0 no],
-     ["checkbox", 1, "yes"],
-     ["date", Time.parse('2011-04-19'), Time.parse('2011-04-19').strftime(I18n.t("date.formats.mmddyy"))]].each do |as, value, expected|
-      field.as = as
-      allow(object).to receive(field.name).and_return(value)
-      expect(field.render_value(object)).to eq(expected)
-    end
-  end
-end