fat_free_crm 0.11.3 → 0.11.4

data/spec/models/entities/opportunity_spec.rb

@@ -28,12 +28,12 @@ describe Opportunity do
 
   it "should create a new instance given valid attributes" do
     @account = FactoryGirl.create(:account)
-    Opportunity.create!(:name => "Opportunity", :account => @account)
+    Opportunity.create!(:name => "Opportunity", :account => @account, :stage => OPPORTUNITY_STATUSES.first)
   end
 
   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)
+    first  = FactoryGirl.create(:opportunity, :name => "Hello", :user => current_user)
+    lambda { FactoryGirl.create(:opportunity, :name => "Hello", :user => current_user) }.should_not raise_error(ActiveRecord::RecordInvalid)
   end
 
   describe "Update existing opportunity" do
@@ -78,13 +78,27 @@ describe Opportunity do
       @opportunity.account.should be_nil
       @opportunity.name.gsub(/#\d+ /,'').should == "Hello"
     end
+
+    it "should set the probability to 0% if opportunity has been lost" do
+      opportunity = FactoryGirl.create(:opportunity, :stage => "prospecting", :probability => 25)
+      opportunity.update_attributes(:stage => 'lost')
+      opportunity.reload
+      opportunity.probability.should == 0
+    end
+
+    it "should set the probablility to 100% if opportunity has been won" do
+      opportunity = FactoryGirl.create(:opportunity, :stage => "prospecting", :probability => 65)
+      opportunity.update_attributes(:stage => 'won')
+      opportunity.reload
+      opportunity.probability.should == 100
+    end
   end
 
-  describe "Named scopes" do
+  describe "Scopes" do
     it "should find non-closed opportunities" do
       Opportunity.delete_all
       @opportunities = [
-        FactoryGirl.create(:opportunity, :stage => nil,        :amount => 1),
+        FactoryGirl.create(:opportunity, :stage => "prospecting", :amount => 1),
         FactoryGirl.create(:opportunity, :stage => "analysis", :amount => 1),
         FactoryGirl.create(:opportunity, :stage => "won",      :amount => 2),
         FactoryGirl.create(:opportunity, :stage => "won",      :amount => 2),
@@ -96,6 +110,19 @@ describe Opportunity do
       Opportunity.lost.sum(:amount).should     ==  6
       Opportunity.sum(:amount).should          == 12
     end
+
+    context "unassigned" do
+      let(:unassigned_opportunity){ FactoryGirl.create(:opportunity, :assignee => nil)}
+      let(:assigned_opportunity){ FactoryGirl.create(:opportunity, :assignee => FactoryGirl.create(:user))}
+
+      it "includes unassigned opportunities" do
+        Opportunity.unassigned.should include(unassigned_opportunity)
+      end
+
+      it "does not include opportunities assigned to a user" do
+        Opportunity.unassigned.should_not include(assigned_opportunity)
+      end
+    end
   end
 
   describe "Attach" do
@@ -104,7 +131,7 @@ describe Opportunity do
     end
 
     it "should return nil when attaching existing asset" do
-      @task = FactoryGirl.create(:task, :asset => @opportunity, :user => @current_user)
+      @task = FactoryGirl.create(:task, :asset => @opportunity, :user => current_user)
       @contact = FactoryGirl.create(:contact)
       @opportunity.contacts << @contact
 
@@ -113,7 +140,7 @@ describe Opportunity do
     end
 
     it "should return non-empty list of attachments when attaching new asset" do
-      @task = FactoryGirl.create(:task, :user => @current_user)
+      @task = FactoryGirl.create(:task, :user => current_user)
       @contact = FactoryGirl.create(:contact)
 
       @opportunity.attach!(@task).should == [ @task ]
@@ -127,7 +154,7 @@ describe Opportunity do
     end
 
     it "should discard a task" do
-      @task = FactoryGirl.create(:task, :asset => @opportunity, :user => @current_user)
+      @task = FactoryGirl.create(:task, :asset => @opportunity, :user => current_user)
       @opportunity.tasks.count.should == 1
 
       @opportunity.discard!(@task)
@@ -173,5 +200,74 @@ describe Opportunity do
   describe "permissions" do
     it_should_behave_like Ability, Opportunity
   end
-end
 
+  describe "scopes" do
+    context "visible_on_dashboard" do
+      before :each do
+        @user = FactoryGirl.create(:user)
+        @o1 = FactoryGirl.create(:opportunity_in_pipeline, :user => @user, :stage => 'prospecting')
+        @o2 = FactoryGirl.create(:opportunity_in_pipeline, :user => @user, :assignee => FactoryGirl.create(:user), :stage => 'prospecting')
+        @o3 = FactoryGirl.create(:opportunity_in_pipeline, :user => FactoryGirl.create(:user), :assignee => @user, :stage => 'prospecting')
+        @o4 = FactoryGirl.create(:opportunity_in_pipeline, :user => FactoryGirl.create(:user), :assignee => FactoryGirl.create(:user), :stage => 'prospecting')
+        @o5 = FactoryGirl.create(:opportunity_in_pipeline, :user => FactoryGirl.create(:user), :assignee => @user, :stage => 'prospecting')
+        @o6 = FactoryGirl.create(:opportunity, :assignee => @user, :stage => 'won')
+        @o7 = FactoryGirl.create(:opportunity, :assignee => @user, :stage => 'lost')
+      end
+
+      it "should show opportunities which have been created by the user and are unassigned" do
+        Opportunity.visible_on_dashboard(@user).should include(@o1)
+      end
+
+      it "should show opportunities which are assigned to the user" do
+        Opportunity.visible_on_dashboard(@user).should include(@o3, @o5)
+      end
+
+      it "should not show opportunities which are not assigned to the user" do
+        Opportunity.visible_on_dashboard(@user).should_not include(@o4)
+      end
+
+      it "should not show opportunities which are created by the user but assigned" do
+        Opportunity.visible_on_dashboard(@user).should_not include(@o2)
+      end
+
+      it "does not include won or lost opportunities" do
+        Opportunity.visible_on_dashboard(@user).should_not include(@o6)
+        Opportunity.visible_on_dashboard(@user).should_not include(@o7)
+      end
+    end
+
+    context "by_closes_on" do
+      let(:o1) { FactoryGirl.create(:opportunity, :closes_on => 3.days.from_now) }
+      let(:o2) { FactoryGirl.create(:opportunity, :closes_on => 7.days.from_now) }
+      let(:o3) { FactoryGirl.create(:opportunity, :closes_on => 5.days.from_now) }
+
+      it "should show opportunities ordered by closes on" do
+        Opportunity.by_closes_on.should == [o1, o3, o2]
+      end
+    end
+
+    context "by_amount" do
+      let(:o1) { FactoryGirl.create(:opportunity, :amount =>  50000) }
+      let(:o2) { FactoryGirl.create(:opportunity, :amount =>  10000) }
+      let(:o3) { FactoryGirl.create(:opportunity, :amount => 750000) }
+
+      it "should show opportunities ordered by amount" do
+        Opportunity.by_amount.should == [o3, o1, o2]
+      end
+    end
+
+    context "not lost" do
+      let(:o1) { FactoryGirl.create(:opportunity, :stage => 'won') }
+      let(:o2) { FactoryGirl.create(:opportunity, :stage => 'lost') }
+      let(:o3) { FactoryGirl.create(:opportunity, :stage => 'analysis') }
+
+      it "should show opportunities which are not lost" do
+        Opportunity.not_lost.should include(o1, o3)
+      end
+
+      it "should not show opportunities which are lost" do
+        Opportunity.not_lost.should_not include(o2)
+      end
+    end
+  end
+end

data/spec/models/fields/custom_field_date_pair_spec.rb

@@ -0,0 +1,106 @@
+# Fat Free CRM
+# Copyright (C) 2008-2011 by Michael Dvorkin
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#------------------------------------------------------------------------------
+
+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)
+      @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)
+      @from.render_value(foo).should == "From #{@today_str}"
+    end
+    
+    it "should be until..." do
+      foo = mock(: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)
+      @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)
+      @from.render_value(foo).should == ""
+    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)
+      @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.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.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.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.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.should_not_receive(:errors)
+      CustomFieldPair.should_not_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 = mock(:cf_event_from => nil)
+      err = mock(:errors); err.stub(:add)
+      foo.should_receive(:errors).and_return(err)
+      from.custom_validator(foo)
+    end
+
+  end
+
+end

data/spec/models/fields/custom_field_pair_spec.rb

@@ -0,0 +1,94 @@
+# Fat Free CRM
+# Copyright (C) 2008-2011 by Michael Dvorkin
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#------------------------------------------------------------------------------
+
+require 'spec_helper'
+
+describe CustomFieldPair do
+
+  class CustomFieldFooPair
+  end
+
+  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')
+      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)
+      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'}
+      @pair2 = {'name' => 'pair2'}
+      @params  = { 'id' => '3', 'field' => @field, 'pair' => {'0' => @pair1, '1' => @pair2} }
+    end
+
+    it "should update the pair" do
+      foo1 = mock(:required => true, :disabled => 'false')
+      foo1.should_receive(:update_attributes).with( @field.merge(@pair1) )
+      foo2 = mock
+      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)
+
+      CustomFieldPair.update_pair(@params).should == [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
+      @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)
+      CustomFieldPair.should_receive(:where).with(:pair_id => 1).and_return([@field1])
+      @field2.paired_with.should == @field1
+    end
+
+  end
+
+end

data/spec/models/fields/custom_field_spec.rb

@@ -26,9 +26,11 @@ describe CustomField do
 
   it "should add a column to the database" do
     CustomField.connection.should_receive(:add_column).
-                with("contacts", "cf_test_field", :string, {})
+                with("contacts", "cf_test_field", 'string', {})
+    Contact.should_receive(:reset_column_information)
+    Contact.should_receive(:serialize_custom_fields!)
 
-    c = FactoryGirl.create(:custom_field,
+    FactoryGirl.create(:custom_field,
                        :as => "string",
                        :name => "cf_test_field",
                        :label => "Test Field",
@@ -36,16 +38,15 @@ describe CustomField do
   end
 
   it "should generate a unique column name for a custom field" do
-    c = FactoryGirl.build(:custom_field, :label => "Test Field", :field_group => FactoryGirl.create(:field_group, :klass_name => "Contact"))
-
-    # Overwrite :klass_column_names with instance variable accessors
-    c.class_eval { attr_accessor :klass_column_names }
-    c.klass_column_names = []
+    field_group = FactoryGirl.build(:field_group, :klass_name => "Contact")
+    c = FactoryGirl.build(:custom_field, :label => "Test Field", :field_group => field_group)
 
-    %w(cf_test_field cf_test_field_2 cf_test_field_3).each do |expected|
-      c.send(:generate_column_name).should == expected
-      c.klass_column_names << expected
+    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 )
     end
+
   end
 
   it "should evaluate the safety of database transitions" do
@@ -68,22 +69,20 @@ describe CustomField do
     end
   end
 
-  # Find ActiveRecord column by name
-  def ar_column(custom_field, column)
-    custom_field.klass.columns.detect{|c| c.name == column }
-  end
-
   it "should change a column's type for safe transitions" do
     CustomField.connection.should_receive(:add_column).
-                with("contacts", "cf_test_field", :string, {})
+                with("contacts", "cf_test_field", 'string', {})
     CustomField.connection.should_receive(:change_column).
-                with("contacts", "cf_test_field", :text, {})
-
+                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")
     c = FactoryGirl.create(:custom_field,
-                       :label => "Test Field",
-                       :name => nil,
-                       :as => "email",
-                       :field_group => FactoryGirl.create(:field_group, :klass_name => "Contact"))
+                           :label => "Test Field",
+                           :name => nil,
+                           :as => "email",
+                           :field_group => field_group)
     c.as = "text"
     c.save
   end
@@ -97,10 +96,31 @@ describe CustomField do
 
     it "should refresh column info and retry on attribute error" do
       Contact.should_receive(:reset_column_information)
+      Contact.should_receive(:serialize_custom_fields!)
 
       contact = FactoryGirl.build(:contact)
       contact.cf_another_new_field.should == nil
     end
   end
-end
 
+  describe "validation" 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.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.should_receive(:errors).and_return(err)
+      event.custom_validator(foo)
+    end
+    
+  end
+  
+end