fat_free_crm 0.13.6 → 0.14.0

data/spec/models/fields/custom_field_date_pair_spec.rb

@@ -6,89 +6,83 @@
 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')
-      @from.stub(:paired_with).and_return(@to)
+      @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)
-      @from.render_value(foo).should == "From #{@today_str}"
+      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)
-      @from.render_value(foo).should == "Until #{@today_str}"
+      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)
-      @from.render_value(foo).should == "From #{@today_str} to #{@today_str}"
+      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)
-      @from.render_value(foo).should == ""
+      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)
-      CustomFieldPair.stub(:find).and_return(@from)
+      @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)
-      foo.should_not_receive(:errors)
+      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)
-      foo.should_not_receive(:errors)
+      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)
-      foo.should_not_receive(:errors)
+      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); err.stub(:add)
-      foo.should_receive(:errors).and_return(err)
+      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)
-      foo.should_not_receive(:errors)
-      CustomFieldPair.should_not_receive(:find)
+      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); err.stub(:add)
-      foo.should_receive(:errors).and_return(err)
+      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

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

@@ -24,108 +24,102 @@
 #  updated_at     :datetime
 #
 
-
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe CustomField do
-
   it "should add a column to the database" do
-    CustomField.connection.should_receive(:add_column).
-                with("contacts", "cf_test_field", 'string', {})
-    Contact.should_receive(:reset_column_information)
-    Contact.should_receive(:serialize_custom_fields!)
+    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!)
 
     FactoryGirl.create(:custom_field,
-                       :as => "string",
-                       :name => "cf_test_field",
-                       :label => "Test Field",
-                       :field_group => FactoryGirl.create(:field_group, :klass_name => "Contact"))
+                       as: "string",
+                       name: "cf_test_field",
+                       label: "Test Field",
+                       field_group: FactoryGirl.create(:field_group, klass_name: "Contact"))
   end
 
   it "should generate a unique column name for a custom field" do
-    field_group = FactoryGirl.build(:field_group, :klass_name => "Contact")
-    c = FactoryGirl.build(:custom_field, :label => "Test Field", :field_group => field_group)
+    field_group = FactoryGirl.build(:field_group, klass_name: "Contact")
+    c = FactoryGirl.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|
-      c.send(:generate_column_name).should == field
-      c.stub(:klass_column_names).and_return( columns << 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 = FactoryGirl.build(:custom_field, :as => "string")
-    c.send(:db_transition_safety, c.as, "email").should == :null
-    c.send(:db_transition_safety, c.as, "text").should == :safe
-    c.send(:db_transition_safety, c.as, "datetime").should == :unsafe
-
-    c = FactoryGirl.build(:custom_field, :as => "datetime")
-    c.send(:db_transition_safety, c.as, "date").should == :safe
-    c.send(:db_transition_safety, c.as, "url").should == :unsafe
+    c = FactoryGirl.build(:custom_field, as: "string")
+    expect(c.send(:db_transition_safety, c.as, "email")).to eq(:null)
+    expect(c.send(:db_transition_safety, c.as, "text")).to eq(:safe)
+    expect(c.send(:db_transition_safety, c.as, "datetime")).to eq(:unsafe)
+
+    c = FactoryGirl.build(:custom_field, as: "datetime")
+    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),
-     "integer" => %w(integer float)}.each do |type, expected_arr|
-      c = FactoryGirl.build(:custom_field, :as => type)
+    { "email"   => %w(check_boxes text string email url tel select radio_buttons),
+      "integer" => %w(integer float) }.each do |type, expected_arr|
+      c = FactoryGirl.build(:custom_field, as: type)
       opts = c.available_as
-      opts.map(&:first).should =~ expected_arr
+      expect(opts.map(&:first)).to match_array(expected_arr)
     end
   end
 
   it "should change a column's type for safe transitions" do
-    CustomField.connection.should_receive(:add_column).
-                with("contacts", "cf_test_field", 'string', {})
-    CustomField.connection.should_receive(:change_column).
-                with("contacts", "cf_test_field", 'text', {})
-    Contact.should_receive(:reset_column_information).twice
-    Contact.should_receive(:serialize_custom_fields!).twice
-    
-    field_group = FactoryGirl.create(:field_group, :klass_name => "Contact")
+    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 = FactoryGirl.create(:field_group, klass_name: "Contact")
     c = FactoryGirl.create(:custom_field,
-                           :label => "Test Field",
-                           :name => nil,
-                           :as => "email",
-                           :field_group => field_group)
+                           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
-      Contact.should_receive(:reset_column_information)
+      expect(Contact).to receive(:reset_column_information)
 
-      lambda { Contact.new :cf_unknown_field => 123 }.should raise_error(ActiveRecord::UnknownAttributeError)
+      expect { Contact.new cf_unknown_field: 123 }.to raise_error(ActiveRecord::UnknownAttributeError)
     end
 
     it "should refresh column info and retry on attribute error" do
-      Contact.should_receive(:reset_column_information)
-      Contact.should_receive(:serialize_custom_fields!)
+      expect(Contact).to receive(:reset_column_information)
+      expect(Contact).to receive(:serialize_custom_fields!)
 
       contact = FactoryGirl.build(:contact)
-      contact.cf_another_new_field.should == nil
+      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); err.stub(:add)
-      foo.should_receive(:errors).and_return(err)
+      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); err.stub(:add)
-      foo.should_receive(:errors).and_return(err)
+      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

@@ -22,7 +22,6 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 describe FieldGroup do
   it "should have field metadata" do
-    FieldGroup.new.should respond_to(:fields)
+    expect(FieldGroup.new).to respond_to(:fields)
   end
 end
-

data/spec/models/fields/field_spec.rb

@@ -27,41 +27,39 @@
 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',
-      :maxlength => 220,
-      :position  => 10
+      name:      'skype_address',
+      label:     'Skype address',
+      as:        'string',
+      maxlength: 220,
+      position:  10
     )
   end
 
-
   it "should return a list of field types" do
-    Field.field_types['string'].should == {'klass' => 'CustomField', 'type' => 'string'}
+    expect(Field.field_types['string']).to eq('klass' => 'CustomField', 'type' => 'string')
   end
 
   it "should return a hash of input options" do
-    Field.new.input_options.should be_a(Hash)
+    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"
+      label: "Availability",
+      name:  "availability"
     )
     object = double('Object')
 
     #  as  |  value  |  expected
     [["check_boxes", [1, 2, 3],               "1, 2<br />3"],
-     ["checkbox",    "0",                     "no"],
+     %w(checkbox 0 no),
      ["checkbox",    1,                       "yes"],
-     ["date",        DateTime.new(2011,4,19), DateTime.new(2011,4,19).strftime(I18n.t("date.formats.mmddyy")) ]].each do |as, value, expected|
+     ["date",        DateTime.new(2011, 4, 19), DateTime.new(2011, 4, 19).strftime(I18n.t("date.formats.mmddyy"))]].each do |as, value, expected|
       field.as = as
-      object.stub(field.name).and_return(value)
-      field.render_value(object).should == expected
+      allow(object).to receive(field.name).and_return(value)
+      expect(field.render_value(object)).to eq(expected)
     end
   end
 end