fat_free_crm 0.11.3 → 0.11.4

data/spec/models/fields/field_spec.rb

@@ -35,7 +35,7 @@ describe Field do
 
 
   it "should return a list of field types" do
-    Field.field_types['string'].should == {:type => :string, :options => nil}
+    Field.field_types['string'].should == {'klass' => 'CustomField', 'type' => 'string'}
   end
 
   it "should return a hash of input options" do
@@ -50,15 +50,13 @@ describe Field do
     object = mock('Object')
 
     #  as  |  value  |  expected
-    [["check_boxes", [1, 2, 3].to_yaml,       "1, 2<br />3"],
-     ["check_boxes", [1, 2, 3],               "1, 2<br />3"],
+    [["check_boxes", [1, 2, 3],               "1, 2<br />3"],
      ["checkbox",    "0",                     "no"],
      ["checkbox",    1,                       "yes"],
-     ["date",        DateTime.new(2011,4,19), "2011-04-19"]].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
     end
   end
 end
-

data/spec/models/observers/entity_observer_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe EntityObserver do
+  [:account, :contact, :lead, :opportunity].each do |entity_type|
+    describe "on creation of #{entity_type}" do
+      let(:assignee) { FactoryGirl.create(:user) }
+      let(:assigner) { FactoryGirl.create(:user) }
+      let!(:entity)  { FactoryGirl.build(entity_type, :user => assigner, :assignee => assignee) }
+      let(:mail) { mock('mail', :deliver => true) }
+
+      before :each do
+        PaperTrail.stub(:whodunnit).and_return(assigner)
+      end
+
+      after :each do
+        entity.save
+      end
+
+      it "sends notification to the assigned user for entity" do
+        UserMailer.should_receive(:assigned_entity_notification).with(entity, assigner).and_return(mail)
+      end
+
+      it "does not notify anyone if the entity is created and assigned to no-one" do
+        entity.assignee = nil
+        UserMailer.should_not_receive(:assigned_entity_notification)
+      end
+
+      it "does not notify me if I have created an entity for myself" do
+        entity.assignee = entity.user = assigner
+        UserMailer.should_not_receive(:assigned_entity_notification)
+      end
+    end
+
+    describe "on update of #{entity_type}" do
+      let(:assignee) { FactoryGirl.create(:user) }
+      let(:assigner) { FactoryGirl.create(:user) }
+      let!(:entity)  { FactoryGirl.create(entity_type, :user => FactoryGirl.create(:user)) }
+      let(:mail) { mock('mail', :deliver => true) }
+
+      before :each do
+        PaperTrail.stub(:whodunnit).and_return(assigner)
+      end
+
+      it "notifies the new owner if the entity is re-assigned" do
+        UserMailer.should_receive(:assigned_entity_notification).with(entity, assigner).and_return(mail)
+        entity.update_attributes(:assignee => assignee)
+      end
+
+      it "does not notify the owner if the entity is not re-assigned" do
+        UserMailer.should_not_receive(:assigned_entity_notification)
+        entity.touch
+      end
+
+      it "does not notify anyone if the entity becomes unassigned" do
+        UserMailer.should_not_receive(:assigned_entity_notification)
+        entity.update_attributes(:assignee => nil)
+      end
+
+      it "does not notify me if I re-assign an entity to myself" do
+        UserMailer.should_not_receive(:assigned_entity_notification)
+        entity.update_attributes(:assignee => assigner)
+      end
+    end
+  end
+end

data/spec/models/polymorphic/task_spec.rb

@@ -47,10 +47,10 @@ describe Task do
       end
   
       it "should create a task with due date selected from the calendar within #{offset ? 'different' : 'current'} timezone" do
-        task = FactoryGirl.create(:task, :bucket => "specific_time", :calendar => "5/5/2020 12:00 AM")
+        task = FactoryGirl.create(:task, :bucket => "specific_time", :calendar => "2020-03-20")
         task.errors.should be_empty
         task.bucket.should == "specific_time"
-        task.due_at.should == DateTime.parse("2020-05-05")
+        task.due_at.to_i.should == Time.parse("2020-03-20").to_i
       end
     end
   end
@@ -104,10 +104,10 @@ describe Task do
   
       it "should update due date if specific calendar date selected within #{offset ? 'different' : 'current'} timezone" do
         task = FactoryGirl.create(:task, :due_at => Time.now.midnight.tomorrow, :bucket => "due_tomorrow")
-        task.update_attributes( { :bucket => "specific_time", :calendar => "05/05/2020 12:00 AM" } )
+        task.update_attributes( { :bucket => "specific_time", :calendar => "2020-03-20" } )
         task.errors.should be_empty
         task.bucket.should == "specific_time"
-        task.due_at.should == DateTime.parse("2020-05-05")
+        task.due_at.to_i.should == Time.parse("2020-03-20").to_i
       end
     end
   
@@ -116,113 +116,109 @@ describe Task do
   describe "Task/Complete" do
     it "should comlete a task that is overdue" do
       task = FactoryGirl.create(:task, :due_at => 2.days.ago, :bucket => "overdue")
-      task.update_attributes(:completed_at => Time.now, :completed_by => @current_user.id)
+      task.update_attributes(:completed_at => Time.now, :completed_by => current_user.id)
       task.errors.should be_empty
       task.completed_at.should_not == nil
-      task.completor.should == @current_user
+      task.completor.should == current_user
     end
   
     it "should complete a task due sometime in the future" do
       task = FactoryGirl.create(:task, :due_at => Time.now.midnight.tomorrow, :bucket => "due_tomorrow")
-      task.update_attributes(:completed_at => Time.now, :completed_by => @current_user.id)
+      task.update_attributes(:completed_at => Time.now, :completed_by => current_user.id)
       task.errors.should be_empty
       task.completed_at.should_not == nil
-      task.completor.should == @current_user
+      task.completor.should == current_user
     end
   
     it "should complete a task that is due on specific date in the future" do
       task = FactoryGirl.create(:task, :calendar => "10/10/2022 12:00 AM", :bucket => "specific_time")
       task.calendar = nil # Calendar is not saved in the database; we need it only to set the :due_at.
-      task.update_attributes(:completed_at => Time.now, :completed_by => @current_user.id)
+      task.update_attributes(:completed_at => Time.now, :completed_by => current_user.id)
       task.errors.should be_empty
       task.completed_at.should_not == nil
-      task.completor.should == @current_user
+      task.completor.should == current_user
     end
   
     it "should complete a task that is due on specific date in the past" do
       task = FactoryGirl.create(:task, :calendar => "10/10/1992 12:00 AM", :bucket => "specific_time")
       task.calendar = nil # Calendar is not saved in the database; we need it only to set the :due_at.
-      task.update_attributes(:completed_at => Time.now, :completed_by => @current_user.id)
+      task.update_attributes(:completed_at => Time.now, :completed_by => current_user.id)
       task.errors.should be_empty
       task.completed_at.should_not == nil
-      task.completor.should == @current_user
+      task.completor.should == current_user
     end
   
     it "completion should preserve original due date" do
-      due_at = 42.days.ago
-      time_format = I18n.t(Setting.task_calendar_with_time ? 
-                           'time.formats.mmddyyyy_hhmm' :
-                           'date.formats.mmddyyyy')
+      due_at = Time.now - 42.days
       task = FactoryGirl.create(:task, :due_at => due_at, :bucket => "specific_time",
-                            :calendar => due_at.strftime(time_format))
-      task.update_attributes(:completed_at => Time.now, :completed_by => @current_user.id, :calendar => '')
+                            :calendar => due_at.strftime('%Y-%m-%d %H:%M'))
+      task.update_attributes(:completed_at => Time.now, :completed_by => current_user.id, :calendar => '')
       task.completed?.should == true
-      parsed_time = DateTime.strptime(due_at.strftime(time_format), time_format).utc
-      task.due_at.to_i.should == parsed_time.to_i
+      task.due_at.should == due_at.utc.strftime('%Y-%m-%d %H:%M')
     end
   end
   
   # named_scope :my, lambda { |user| { :conditions => [ "(user_id = ? AND assigned_to IS NULL) OR assigned_to = ?", user.id, user.id ], :include => :assignee } }
   describe "task.my?" do
     it "should match a task created by the user" do
-      task = FactoryGirl.create(:task, :user => @current_user, :assignee => nil)
-      task.my?(@current_user).should == true
+      task = FactoryGirl.create(:task, :user => current_user, :assignee => nil)
+      task.my?(current_user).should == true
     end
   
     it "should match a task assigned to the user" do
-      task = FactoryGirl.create(:task, :user => FactoryGirl.create(:user), :assignee => @current_user)
-      task.my?(@current_user).should == true
+      task = FactoryGirl.create(:task, :user => FactoryGirl.create(:user), :assignee => current_user)
+      task.my?(current_user).should == true
     end
   
     it "should Not match a task not created by the user" do
       task = FactoryGirl.create(:task, :user => FactoryGirl.create(:user))
-      task.my?(@current_user).should == false
+      task.my?(current_user).should == false
     end
   
     it "should Not match a task created by the user but assigned to somebody else" do
-      task = FactoryGirl.create(:task, :user => @current_user, :assignee => FactoryGirl.create(:user))
-      task.my?(@current_user).should == false
+      task = FactoryGirl.create(:task, :user => current_user, :assignee => FactoryGirl.create(:user))
+      task.my?(current_user).should == false
     end
   end
   
   # named_scope :assigned_by, lambda { |user| { :conditions => [ "user_id = ? AND assigned_to IS NOT NULL AND assigned_to != ?", user.id, user.id ], :include => :assignee } }
   describe "task.assigned_by?" do
     it "should match a task assigned by the user to somebody else" do
-      task = FactoryGirl.create(:task, :user => @current_user, :assignee => FactoryGirl.create(:user))
-      task.assigned_by?(@current_user).should == true
+      task = FactoryGirl.create(:task, :user => current_user, :assignee => FactoryGirl.create(:user))
+      task.assigned_by?(current_user).should == true
     end
   
     it "should Not match a task not created by the user" do
       task = FactoryGirl.create(:task, :user => FactoryGirl.create(:user))
-      task.assigned_by?(@current_user).should == false
+      task.assigned_by?(current_user).should == false
     end
   
     it "should Not match a task not assigned to anybody" do
       task = FactoryGirl.create(:task, :assignee => nil)
-      task.assigned_by?(@current_user).should == false
+      task.assigned_by?(current_user).should == false
     end
   
     it "should Not match a task assigned to the user" do
-      task = FactoryGirl.create(:task, :assignee => @current_user)
-      task.assigned_by?(@current_user).should == false
+      task = FactoryGirl.create(:task, :assignee => current_user)
+      task.assigned_by?(current_user).should == false
     end
   end
   
   # named_scope :tracked_by, lambda { |user| { :conditions => [ "user_id = ? OR assigned_to = ?", user.id, user.id ], :include => :assignee } }
   describe "task.tracked_by?" do
     it "should match a task created by the user" do
-      task = FactoryGirl.create(:task, :user => @current_user)
-      task.tracked_by?(@current_user).should == true
+      task = FactoryGirl.create(:task, :user => current_user)
+      task.tracked_by?(current_user).should == true
     end
   
     it "should match a task assigned to the user" do
-      task = FactoryGirl.create(:task, :assignee => @current_user)
-      task.tracked_by?(@current_user).should == true
+      task = FactoryGirl.create(:task, :assignee => current_user)
+      task.tracked_by?(current_user).should == true
     end
   
     it "should Not match a task that is neither created nor assigned to the user" do
       task = FactoryGirl.create(:task, :user => FactoryGirl.create(:user), :assignee => FactoryGirl.create(:user))
-      task.tracked_by?(@current_user).should == false
+      task.tracked_by?(current_user).should == false
     end
   end
   
@@ -262,96 +258,56 @@ describe Task do
   end
   
   describe "#parse_calendar_date" do
-    before :each do
-      I18n.locale = "de"
-      @task = Task.new
-      @task.bucket = "specific_time"
-      @backup_with_time = Setting.task_calendar_with_time
-    end
-    
-    after :each do
-      I18n.locale = "en-Us"
-      Setting.task_calendar_with_time = @backup_with_time
-    end
-    
-    context "german" do
-      context "date" do
-        before :each do
-          Setting.task_calendar_with_time = false
-        end
-        
-        it "should translate: \"20 Jänner 2012\" to \"20 January 2012\"" do
-          @task.calendar = "20 Jänner 2012"
-          @task.send(:parse_calendar_date).should == "20 January 2012"
-        end
-
-        it "should translate: \"20 Februar 2012\" to \"20 February 2012\"" do
-          @task.calendar = "20 Februar 2012"
-          @task.send(:parse_calendar_date).should == "20 February 2012"
-        end
-
-        it "should translate: \"20 März 2012\" to \"20 March 2012\"" do
-          @task.calendar = "20 März 2012"
-          @task.send(:parse_calendar_date).should == "20 March 2012"
-        end
 
-        it "should translate: \"20 April 2012\" to \"20 April 2012\"" do
-          @task.calendar = "20 April 2012"
-          @task.send(:parse_calendar_date).should == "20 April 2012"
-        end
-
-        it "should translate: \"20 Mai 2012\" to \"20 May 2012\"" do
-          @task.calendar = "20 Mai 2012"
-          @task.send(:parse_calendar_date).should == "20 May 2012"
-        end
+    it "should parse the date" do
+      @task = Task.new(:calendar => '2020-12-23')
+      Time.should_receive(:parse).with('2020-12-23')
+      @task.send(:parse_calendar_date)
+    end
 
-        it "should translate: \"20 Juni 2012\" to \"20 June 2012\"" do
-          @task.calendar = "20 Juni 2012"
-          @task.send(:parse_calendar_date).should == "20 June 2012"
-        end
+  end
 
-        it "should translate: \"20 Juli 2012\" to \"20 July 2012\"" do
-          @task.calendar = "20 Juli 2012"
-          @task.send(:parse_calendar_date).should == "20 July 2012"
-        end
+  describe "scopes" do
+    context "visible_on_dashboard" do
+      before :each do
+        @user = FactoryGirl.create(:user)
+        @t1 = FactoryGirl.create(:task, :user => @user)
+        @t2 = FactoryGirl.create(:task, :user => @user, :assignee => FactoryGirl.create(:user))
+        @t3 = FactoryGirl.create(:task, :user => FactoryGirl.create(:user), :assignee => @user)
+        @t4 = FactoryGirl.create(:task, :user => FactoryGirl.create(:user), :assignee => FactoryGirl.create(:user))
+        @t5 = FactoryGirl.create(:task, :user => FactoryGirl.create(:user), :assignee => @user)
+        @t6 = FactoryGirl.create(:completed_task, :assignee => @user)
+      end
 
-        it "should translate: \"20 August 2012\" to \"20 August 2012\"" do
-          @task.calendar = "20 August 2012"
-          @task.send(:parse_calendar_date).should == "20 August 2012"
-        end
+      it "should show tasks which have been created by the user and are unassigned" do
+        Task.visible_on_dashboard(@user).should include(@t1)
+      end
 
-        it "should translate: \"20 September 2012\" to \"20 September 2012\"" do
-          @task.calendar = "20 September 2012"
-          @task.send(:parse_calendar_date).should == "20 September 2012"
-        end
+      it "should show tasks which are assigned to the user" do
+        Task.visible_on_dashboard(@user).should include(@t3, @t5)
+      end
 
-        it "should translate: \"20 Oktober 2012\" to \"20 October 2012\"" do
-          @task.calendar = "20 Oktober 2012"
-          @task.send(:parse_calendar_date).should == "20 October 2012"
-        end
+      it "should not show tasks which are not assigned to the user" do
+        Task.visible_on_dashboard(@user).should_not include(@t4)
+      end
 
-        it "should translate: \"20 November 2012\" to \"20 November 2012\"" do
-          @task.calendar = "20 November 2012"
-          @task.send(:parse_calendar_date).should == "20 November 2012"
-        end
+      it "should not show tasks which are created by the user but assigned" do
+        Task.visible_on_dashboard(@user).should_not include(@t2)
+      end
 
-        it "should translate: \"20 Dezember 2012\" to \"20 December 2012\"" do
-          @task.calendar = "20 Dezember 2012"
-          @task.send(:parse_calendar_date).should == "20 December 2012"
-        end
+      it "should not include completed tasks" do
+        Task.visible_on_dashboard(@user).should_not include(@t6)
       end
-      
-      context 'datetime' do
-        before :each do
-          Setting.task_calendar_with_time = true
-        end
-        
-        it "should translate: \"20 Jänner 2012 12:27\" to \"20 January 2012 12:27\"" do
-          @task.calendar = "20 Jänner 2012 12:27"
-          @task.send(:parse_calendar_date).should == "20 January 2012 12:27"
-        end
+    end
+
+    context "by_due_at" do
+      it "should show tasks ordered by due_at" do
+        t1 = FactoryGirl.create(:task, :name => 't1', :bucket => "due_asap")
+        t2 = FactoryGirl.create(:task, :calendar => 5.days.from_now.strftime("%Y-%m-%d %H:%M"), :bucket => "specific_time")
+        t3 = FactoryGirl.create(:task, :name => 't3',  :bucket => "due_next_week")
+        t4 = FactoryGirl.create(:task, :calendar => 20.days.from_now.strftime("%Y-%m-%d %H:%M"), :bucket => "specific_time")
+        Task.by_due_at.should == [t1, t2, t3, t4]
       end
     end
   end
 end
-

data/spec/models/polymorphic/version_spec.rb

@@ -19,7 +19,7 @@ describe Version do
 
   before do
     login
-    PaperTrail.whodunnit = @current_user.id.to_s
+    PaperTrail.whodunnit = current_user.id.to_s
   end
 
   it "should create a new instance given valid attributes" do
@@ -37,27 +37,27 @@ describe Version do
     end
 
     it "should select all versions except one" do
-      @versions = Version.for(@current_user).exclude_events(:view)
+      @versions = Version.for(current_user).exclude_events(:view)
       @versions.map(&:event).sort.should == %w(create destroy update)
     end
 
     it "should select all versions except many" do
-      @versions = Version.for(@current_user).exclude_events(:create, :update, :destroy)
+      @versions = Version.for(current_user).exclude_events(:create, :update, :destroy)
       @versions.map(&:event).should == %w(view)
     end
 
     it "should select one requested version" do
-      @versions = Version.for(@current_user).include_events(:destroy)
+      @versions = Version.for(current_user).include_events(:destroy)
       @versions.map(&:event).should == %w(destroy)
     end
 
     it "should select many requested versions" do
-      @versions = Version.for(@current_user).include_events(:create, :update)
+      @versions = Version.for(current_user).include_events(:create, :update)
       @versions.map(&:event).sort.should == %w(create update)
     end
 
     it "should select versions for given user" do
-      @versions = Version.for(@current_user)
+      @versions = Version.for(current_user)
       @versions.map(&:event).sort.should == %w(create destroy update view)
     end
   end
@@ -66,7 +66,7 @@ describe Version do
     describe "Create, update, and delete (#{item})" do
       before :each do
         PaperTrail.enabled = true
-        @item = FactoryGirl.create(item.to_sym, :user => @current_user)
+        @item = FactoryGirl.create(item.to_sym, :user => current_user)
         @conditions = {:item_id => @item.id, :item_type => @item.class.name, :whodunnit => PaperTrail.whodunnit}
       end
 
@@ -94,7 +94,7 @@ describe Version do
       end
 
       it "should add a version when commenting on a #{item}" do
-        @comment = FactoryGirl.create(:comment, :commentable => @item, :user => @current_user)
+        @comment = FactoryGirl.create(:comment, :commentable => @item, :user => current_user)
 
         @version = Version.where({:related_id => @item.id, :related_type => @item.class.name, :whodunnit => PaperTrail.whodunnit, :event => 'create'}).first
         @version.should_not == nil
@@ -125,7 +125,7 @@ describe Version do
 
   describe "Action refinements for task updates" do
     before do
-      @task = FactoryGirl.create(:task, :user => @current_user)
+      @task = FactoryGirl.create(:task, :user => current_user)
       @conditions = {:item_id => @task.id, :item_type => @task.class.name, :whodunnit => PaperTrail.whodunnit}
     end
 
@@ -137,7 +137,7 @@ describe Version do
     end
 
     it "should create 'reassigned' task event" do
-      @task.update_attribute(:assigned_to, @current_user.id + 1)
+      @task.update_attribute(:assigned_to, current_user.id + 1)
       @versions = Version.where(@conditions)
 
       @versions.map(&:event).sort.should == %w(reassign)
@@ -153,7 +153,7 @@ describe Version do
 
   describe "Rejecting a lead" do
     before do
-      @lead = FactoryGirl.create(:lead, :user => @current_user, :status => "new")
+      @lead = FactoryGirl.create(:lead, :user => current_user, :status => "new")
       @conditions = {:item_id => @lead.id, :item_type => @lead.class.name, :whodunnit => PaperTrail.whodunnit}
     end
 
@@ -173,7 +173,7 @@ describe Version do
     end
 
     it "should not show the create/update versions if the item is private" do
-      @item = FactoryGirl.create(:account, :user => @current_user, :access => "Private")
+      @item = FactoryGirl.create(:account, :user => current_user, :access => "Private")
       @item.update_attribute(:updated_at,  1.second.ago)
 
       @versions = Version.where({:item_id => @item.id, :item_type => @item.class.name})
@@ -183,7 +183,7 @@ describe Version do
     end
 
     it "should not show the destroy version if the item is private" do
-      @item = FactoryGirl.create(:account, :user => @current_user, :access => "Private")
+      @item = FactoryGirl.create(:account, :user => current_user, :access => "Private")
       @item.destroy
 
       @versions = Version.where({:item_id => @item.id, :item_type => @item.class.name})
@@ -194,9 +194,9 @@ describe Version do
 
     it "should not show create/update versions if the item was not shared with the user" do
       @item = FactoryGirl.create(:account,
-        :user => @current_user,
+        :user => current_user,
         :access => "Shared",
-        :permissions => [ FactoryGirl.build(:permission, :user => @current_user, :asset => @item) ]
+        :permissions => [ FactoryGirl.build(:permission, :user => current_user, :asset => @item) ]
       )
       @item.update_attribute(:updated_at, 1.second.ago)
 
@@ -208,9 +208,9 @@ describe Version do
 
     it "should not show the destroy version if the item was not shared with the user" do
       @item = FactoryGirl.create(:account,
-        :user => @current_user,
+        :user => current_user,
         :access => "Shared",
-        :permissions => [ FactoryGirl.build(:permission, :user => @current_user, :asset => @item) ]
+        :permissions => [ FactoryGirl.build(:permission, :user => current_user, :asset => @item) ]
       )
       @item.destroy
 
@@ -222,7 +222,7 @@ describe Version do
 
     it "should show create/update versions if the item was shared with the user" do
       @item = FactoryGirl.create(:account,
-        :user => @current_user,
+        :user => current_user,
         :access => "Shared",
         :permissions => [ FactoryGirl.build(:permission, :user => @user, :asset => @item) ]
       )