fat_free_crm 0.12.3 → 0.13.0

data/spec/lib/fields_spec.rb

@@ -21,82 +21,82 @@ describe 'FatFreeCRM::Fields' do
   it do
     Foo.new.should respond_to(:field_groups)
   end
-  
+
   it do
     Foo.should respond_to(:serialize_custom_fields!)
   end
-  
+
   it do
     Foo.should respond_to(:fields)
   end
-  
+
   it "calling has_fields should invoke serialize_custom_fields!" do
     Bar.should_receive(:serialize_custom_fields!)
     Bar.has_fields
   end
-  
+
   describe "field_groups" do
-  
+
     it "should call FieldGroup" do
       ActiveRecord::Base.connection.should_receive(:table_exists?).with('field_groups').and_return(true)
-      dummy_scope = mock
+      dummy_scope = double
       dummy_scope.should_receive(:order).with(:position)
       FieldGroup.should_receive(:where).and_return(dummy_scope)
       Foo.new.field_groups
     end
-    
+
     it "should not call FieldGroup if table doesn't exist (migrations not yet run)" do
       ActiveRecord::Base.connection.should_receive(:table_exists?).with('field_groups').and_return(false)
       Foo.new.field_groups.should == []
     end
-  
+
   end
-  
+
   describe "fields" do
-    
+
     before(:each) do
-      @f1 = mock(Field)
-      @f2 = mock(Field)
-      @f3 = mock(Field)
-      @field_groups = [mock(FieldGroup, :fields => [@f1, @f2]), mock(FieldGroup, :fields => [@f3])]
+      @f1 = double(Field)
+      @f2 = double(Field)
+      @f3 = double(Field)
+      @field_groups = [double(FieldGroup, :fields => [@f1, @f2]), double(FieldGroup, :fields => [@f3])]
     end
-  
+
     it "should convert field_groups into a flattened list of fields" do
       Foo.should_receive(:field_groups).and_return(@field_groups)
       Foo.fields.should == [@f1, @f2, @f3]
     end
-  
+
   end
-  
+
   describe "serialize_custom_fields!" do
-  
+
     before(:each) do
-      @f1 = mock(Field, :as => 'check_boxes', :name => 'field1')
-      @f2 = mock(Field, :as => 'date', :name => 'field2')
+      @f1 = double(Field, :as => 'check_boxes', :name => 'field1')
+      @f2 = double(Field, :as => 'date', :name => 'field2')
     end
-    
+
     it "should serialize checkbox fields as Array" do
       Foo.stub(:serialized_attributes).and_return( {:field1 => @f1, :field2 => @f2} )
       Foo.should_receive(:fields).and_return([@f1, @f2])
       Foo.should_receive(:serialize).with(:field1, Array)
       Foo.serialize_custom_fields!
     end
-  
+
   end
-  
+
   it "should validate custom fields" do
     foo = Foo.new
     foo.should_receive(:custom_fields_validator)
     foo.should be_valid
   end
-  
+
   describe "custom_fields_validator" do
-  
+
     before(:each) do
-      @f1 = mock(Field)
-      @field_groups = [ mock(FieldGroup, :fields => [@f1]) ]
+      @f1 = double(Field)
+      @field_groups = [ double(FieldGroup, :fields => [@f1]) ]
     end
-  
+
     it "should call custom_validator on each custom field" do
       foo = Foo.new
       @f1.should_receive(:custom_validator).with(foo)
@@ -105,5 +105,5 @@ describe 'FatFreeCRM::Fields' do
     end
 
   end
-  
+
 end

data/spec/lib/mail_processor/base_spec.rb

@@ -67,7 +67,7 @@ describe FatFreeCRM::MailProcessor::Base do
   describe "Discarding a message" do
     before(:each) do
       mock_connect
-      @uid = mock
+      @uid = double
       @crawler.send(:connect!)
     end
 
@@ -90,7 +90,7 @@ describe FatFreeCRM::MailProcessor::Base do
   describe "Archiving a message" do
     before(:each) do
       mock_connect
-      @uid = mock
+      @uid = double
       @crawler.send(:connect!)
     end
 
@@ -112,16 +112,16 @@ describe FatFreeCRM::MailProcessor::Base do
   #------------------------------------------------------------------------------
   describe "Validating email" do
     before(:each) do
-      @email = mock
+      @email = double
     end
 
     it "should be valid email if its contents type is text/plain" do
-      @email.stub!(:content_type).and_return("text/plain")
+      @email.stub(:content_type).and_return("text/plain")
       @crawler.send(:is_valid?, @email).should == true
     end
 
     it "should be invalid email if its contents type is not text/plain" do
-      @email.stub!(:content_type).and_return("text/html")
+      @email.stub(:content_type).and_return("text/html")
       @crawler.send(:is_valid?, @email).should == false
     end
   end
@@ -130,8 +130,8 @@ describe FatFreeCRM::MailProcessor::Base do
   describe "Finding email sender among users" do
     before(:each) do
       @from = [ "Aaron@Example.Com", "Ben@Example.com" ]
-      @email = mock
-      @email.stub!(:from).and_return(@from)
+      @email = double
+      @email.stub(:from).and_return(@from)
     end
 
     it "should find non-suspended user that matches From: field" do

data/spec/lib/mail_processor/dropbox_spec.rb

@@ -288,17 +288,17 @@ describe FatFreeCRM::MailProcessor::Dropbox do
     describe "'access'" do
 
       it "should be 'Private' if default setting is 'Private'" do
-        Setting.stub!(:default_access).and_return('Private')
+        Setting.stub(:default_access).and_return('Private')
         @crawler.send(:default_access).should == "Private"
       end
 
       it "should be 'Public' if default setting is 'Public'" do
-        Setting.stub!(:default_access).and_return('Public')
+        Setting.stub(:default_access).and_return('Public')
         @crawler.send(:default_access).should == "Public"
       end
 
       it "should be 'Private' if default setting is 'Shared'" do
-        Setting.stub!(:default_access).and_return('Shared')
+        Setting.stub(:default_access).and_return('Shared')
         @crawler.send(:default_access).should == "Private"
       end
 

data/spec/lib/view_factory_spec.rb

@@ -11,13 +11,13 @@ describe FatFreeCRM::ViewFactory do
   before(:each) do
     FatFreeCRM::ViewFactory.send(:class_variable_set, '@@views', [])
   end
-  
+
   describe "initialization" do
-  
+
     before(:each) do
-      @view_params = {:name => 'brief', :title => 'Brief View', :icon => 'brief.png', :controllers => ['contacts'], :actions => ['show', 'index']}
+      @view_params = {:name => 'brief', :title => 'Brief View', :icon => 'fa-bars', :controllers => ['contacts'], :actions => ['show', 'index']}
     end
-    
+
     it "should initialize with required parameters" do
       view = FatFreeCRM::ViewFactory.new @view_params
       view.name.should == 'brief'
@@ -26,48 +26,48 @@ describe FatFreeCRM::ViewFactory do
       view.actions.should include('show')
       view.actions.should include('index')
     end
-    
+
     it "should register view with ViewFactory" do
       FatFreeCRM::ViewFactory.send(:class_variable_get, '@@views').size.should == 0
       FatFreeCRM::ViewFactory.new @view_params
       FatFreeCRM::ViewFactory.send(:class_variable_get, '@@views').size.should == 1
     end
-    
+
     it "should not register the same view twice" do
       FatFreeCRM::ViewFactory.new @view_params
       FatFreeCRM::ViewFactory.new @view_params
       views = FatFreeCRM::ViewFactory.send(:class_variable_get, '@@views')
       views.size.should == 1
     end
-    
+
   end
 
   describe "views_for" do
-    
+
     before(:each) do
       @v1 = FatFreeCRM::ViewFactory.new :name => 'brief', :title => 'Brief View', :controllers => ['contacts'], :actions => ['show', 'index']
       @v2 = FatFreeCRM::ViewFactory.new :name => 'long', :title => 'Long View', :controllers => ['contacts'], :actions => ['show']
       @v3 = FatFreeCRM::ViewFactory.new :name => 'full', :title => 'Full View', :controllers => ['accounts'], :actions => ['show']
     end
-    
+
     it "should return 'brief' view for ContactsController#index" do
       FatFreeCRM::ViewFactory.views_for(:controller => 'contacts', :action => 'index').should == [@v1]
     end
-    
+
     it "should return 'brief' and 'long' view for ContactsController#show" do
       views = FatFreeCRM::ViewFactory.views_for(:controller => 'contacts', :action => 'show')
       views.should include(@v1)
       views.should include(@v2)
     end
-    
+
     it "should return 'full' view for AccountsController#show" do
       FatFreeCRM::ViewFactory.views_for(:controller => 'accounts', :action => 'show').should == [@v3]
     end
-    
+
     it "should return no views for TasksController#show" do
       FatFreeCRM::ViewFactory.views_for(:controller => 'tasks', :action => 'show').should == []
     end
-    
+
   end
-  
+
 end

data/spec/models/entities/opportunity_spec.rb

@@ -37,7 +37,7 @@ describe Opportunity do
 
   it "should be possible to create opportunity with the same name" do
     first  = FactoryGirl.create(:opportunity, :name => "Hello", :user => current_user)
-    lambda { FactoryGirl.create(:opportunity, :name => "Hello", :user => current_user) }.should_not raise_error(ActiveRecord::RecordInvalid)
+    expect { FactoryGirl.create(:opportunity, :name => "Hello", :user => current_user) }.to_not raise_error()
   end
 
   it "have a default stage" do

data/spec/models/fields/custom_field_date_pair_spec.rb

@@ -12,28 +12,28 @@ describe CustomFieldDatePair 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.stub(:paired_with).and_return(@to)
       @today = Date.today
       @today_str = @today.strftime(I18n.t("date.formats.mmddyy"))
     end
   
     it "should be from..." do
-      foo = mock(:cf_event_from => @today, :cf_event_to => nil)
+      foo = double(:cf_event_from => @today, :cf_event_to => nil)
       @from.render_value(foo).should == "From #{@today_str}"
     end
     
     it "should be until..." do
-      foo = mock(:cf_event_from => nil, :cf_event_to => @today)
+      foo = double(:cf_event_from => nil, :cf_event_to => @today)
       @from.render_value(foo).should == "Until #{@today_str}"
     end
     
     it "should be from ... to" do
-      foo = mock(:cf_event_from => @today, :cf_event_to => @today)
+      foo = double(:cf_event_from => @today, :cf_event_to => @today)
       @from.render_value(foo).should == "From #{@today_str} to #{@today_str}"
     end
     
     it "should be empty string" do
-      foo = mock(:cf_event_from => nil, :cf_event_to => nil)
+      foo = double(:cf_event_from => nil, :cf_event_to => nil)
       @from.render_value(foo).should == ""
     end
 
@@ -44,38 +44,38 @@ describe CustomFieldDatePair 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)
+      CustomFieldPair.stub(: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 = mock(:cf_event_from => nil, :cf_event_to => @today)
+      foo = double(:cf_event_from => nil, :cf_event_to => @today)
       foo.should_not_receive(:errors)
       @to.custom_validator(foo)
     end
 
     it "when to is nil it should be valid" do
-      foo = mock(:cf_event_from => @today, :cf_event_to => nil)
+      foo = double(:cf_event_from => @today, :cf_event_to => nil)
       foo.should_not_receive(:errors)
       @to.custom_validator(foo)
     end
     
     it "when from <= to it should be valid" do
-      foo = mock(:cf_event_from => @today, :cf_event_to => @today)
+      foo = double(:cf_event_from => @today, :cf_event_to => @today)
       foo.should_not_receive(:errors)
       @to.custom_validator(foo)
     end
     
     it "when from > to it should not be valid" do
-      foo = mock(:cf_event_from => @today, :cf_event_to => @today - 1.day)
-      err = mock(:errors); err.stub(:add)
+      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)
       @to.custom_validator(foo)
     end
     
     it "should ignore validation when called on from" do
-      foo = mock(:cf_event_from => @today, :cf_event_to => @today - 1.day)
+      foo = double(:cf_event_from => @today, :cf_event_to => @today - 1.day)
       foo.should_not_receive(:errors)
       CustomFieldPair.should_not_receive(:find)
       @from.custom_validator(foo)
@@ -83,8 +83,8 @@ describe CustomFieldDatePair do
 
     it "should call custom field validation on super class" do
       from = CustomFieldDatePair.new(:name => 'cf_event_from', :required => true)
-      foo = mock(:cf_event_from => nil)
-      err = mock(:errors); err.stub(:add)
+      foo = double(:cf_event_from => nil)
+      err = double(:errors); err.stub(:add)
       foo.should_receive(:errors).and_return(err)
       from.custom_validator(foo)
     end

data/spec/models/fields/custom_field_pair_spec.rb

@@ -13,31 +13,31 @@ describe CustomFieldPair do
   it "should respond to pair" do
     CustomFieldPair.new.should 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 = mock(:id => 3, :required => true, :disabled => 'false')
+      foo1 = double(:id => 3, :required => true, :disabled => 'false')
       CustomFieldFooPair.should_receive(:create).with( params1 ).and_return(foo1)
       params2 = @field.merge(@pair2).merge('pair_id' => 3, 'required' => true, 'disabled' => 'false')
-      foo2 = mock(:id => 5)
+      foo2 = double(:id => 5)
       CustomFieldFooPair.should_receive(:create).with( params2 ).and_return(foo2)
 
       CustomFieldPair.create_pair(@params).should == [foo1, foo2]
     end
-    
+
   end
 
   describe "update_pair" do
-  
+
     before(:each) do
       @field = {'as' => 'foopair', 'field_group_id' => 1, 'label' => 'Event'}
       @pair1 = {'name' => 'pair1'}
@@ -46,9 +46,9 @@ describe CustomFieldPair do
     end
 
     it "should update the pair" do
-      foo1 = mock(:required => true, :disabled => 'false')
+      foo1 = double(:required => true, :disabled => 'false')
       foo1.should_receive(:update_attributes).with( @field.merge(@pair1) )
-      foo2 = mock
+      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)
@@ -57,19 +57,19 @@ describe CustomFieldPair do
     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
       @field1.should_receive(:pair).and_return(@field2)
       @field1.paired_with.should == @field2
     end
-    
+
     it "should return the 1st field" do
       @field2.should_receive(:pair).and_return(nil)
       @field2.should_receive(:id).and_return(1)

data/spec/models/fields/custom_field_spec.rb

@@ -49,7 +49,7 @@ describe CustomField do
     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 )
+      c.stub(:klass_column_names).and_return( columns << field )
     end
 
   end
@@ -112,16 +112,16 @@ describe CustomField do
   
     it "should have errors if custom field is required" do
       event = CustomField.new(:name => 'cf_event', :required => true)
-      foo = mock(:cf_event => nil)
-      err = mock(:errors); err.stub(:add)
+      foo = double(:cf_event => nil)
+      err = double(:errors); err.stub(:add)
       foo.should_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 = mock(:cf_event => "This is too long")
-      err = mock(:errors); err.stub(:add)
+      foo = double(:cf_event => "This is too long")
+      err = double(:errors); err.stub(:add)
       foo.should_receive(:errors).and_return(err)
       event.custom_validator(foo)
     end