reduced_fat_crm 0.14.0

data/spec/controllers/entities_controller_spec.rb

@@ -0,0 +1,40 @@
+# 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 EntitiesController do
+  describe "parse_query_and_tags" do
+    it "should parse empty string" do
+      str = ""
+      expect(controller.send(:parse_query_and_tags, str)).to eq(['', ''])
+    end
+
+    it "should parse #tags" do
+      str = "#test"
+      expect(controller.send(:parse_query_and_tags, str)).to eq(['', 'test'])
+    end
+
+    it "should parse no tags" do
+      str = "test query"
+      expect(controller.send(:parse_query_and_tags, str)).to eq(['test query', ''])
+    end
+
+    it "should parse tags and query" do
+      str = "#real Billy Bones #pirate"
+      expect(controller.send(:parse_query_and_tags, str)).to eq(["Billy Bones", "real, pirate"])
+    end
+
+    it "should parse strange characters" do
+      str = "#this is #a test !@$%^~ #parseme"
+      expect(controller.send(:parse_query_and_tags, str)).to eq(['is test !@$%^~', 'this, a, parseme'])
+    end
+
+    it "should strip whitespace" do
+      str = "     test    me    "
+      expect(controller.send(:parse_query_and_tags, str)).to eq(['test me', ''])
+    end
+  end
+end

data/spec/controllers/home_controller_spec.rb

@@ -0,0 +1,231 @@
+# 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 File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe HomeController do
+  # GET /
+  #----------------------------------------------------------------------------
+  describe "responding to GET /" do
+    before(:each) do
+      require_user
+    end
+
+    it "should get a list of activities" do
+      activity = FactoryGirl.create(:version, item: FactoryGirl.create(:account, user: current_user))
+      expect(controller).to receive(:get_activities).once.and_return([activity])
+      get :index
+      expect(assigns[:activities]).to eq([activity])
+    end
+
+    it "should not include views in the list of activities" do
+      activity = FactoryGirl.create(:version, item: FactoryGirl.create(:account, user: @current_user), event: "view")
+      expect(controller).to receive(:get_activities).once.and_return([])
+
+      get :index
+      expect(assigns[:activities]).to eq([])
+    end
+
+    it "should get a list of my tasks ordered by due_at" do
+      task_1 = FactoryGirl.create(:task, name: "Your first task", bucket: "due_asap", assigned_to: current_user.id)
+      task_2 = FactoryGirl.create(:task, name: "Another task for you", bucket: "specific_time", calendar: 5.days.from_now.to_s, assigned_to: current_user.id)
+      task_3 = FactoryGirl.create(:task, name: "Third Task", bucket: "due_next_week", assigned_to: current_user.id)
+      task_4 = FactoryGirl.create(:task, name: "i've assigned it to myself", user: current_user, calendar: 20.days.from_now.to_s, assigned_to: nil, bucket: "specific_time")
+
+      FactoryGirl.create(:task, name: "Someone else's Task", user_id: current_user.id, bucket: "due_asap", assigned_to: FactoryGirl.create(:user).id)
+      FactoryGirl.create(:task, name: "Not my task", bucket: "due_asap", assigned_to: FactoryGirl.create(:user).id)
+
+      get :index
+      expect(assigns[:my_tasks]).to eq([task_1, task_2, task_3, task_4])
+    end
+
+    it "should not display completed tasks" do
+      task_1 = FactoryGirl.create(:task, user_id: current_user.id, name: "Your first task", bucket: "due_asap", assigned_to: current_user.id)
+      task_2 = FactoryGirl.create(:task, user_id: current_user.id, name: "Completed task", bucket: "due_asap", completed_at: 1.days.ago, completed_by: current_user.id, assigned_to: current_user.id)
+
+      get :index
+      expect(assigns[:my_tasks]).to eq([task_1])
+    end
+
+    it "should get a list of my opportunities ordered by closes_on" do
+      opportunity_1 = FactoryGirl.create(:opportunity, name: "Your first opportunity", closes_on: 15.days.from_now, assigned_to: current_user.id, stage: 'proposal')
+      opportunity_2 = FactoryGirl.create(:opportunity, name: "Another opportunity for you", closes_on: 10.days.from_now, assigned_to: current_user.id, stage: 'proposal')
+      opportunity_3 = FactoryGirl.create(:opportunity, name: "Third Opportunity", closes_on: 5.days.from_now, assigned_to: current_user.id, stage: 'proposal')
+      opportunity_4 = FactoryGirl.create(:opportunity, name: "Fourth Opportunity", closes_on: 50.days.from_now, assigned_to: nil, user_id: current_user.id, stage: 'proposal')
+
+      FactoryGirl.create(:opportunity_in_pipeline, name: "Someone else's Opportunity", assigned_to: FactoryGirl.create(:user).id, stage: 'proposal')
+      FactoryGirl.create(:opportunity_in_pipeline, name: "Not my opportunity", assigned_to: FactoryGirl.create(:user).id, stage: 'proposal')
+
+      get :index
+      expect(assigns[:my_opportunities]).to eq([opportunity_3, opportunity_2, opportunity_1, opportunity_4])
+    end
+
+    it "should get a list of my accounts ordered by name" do
+      account_1 = FactoryGirl.create(:account, name: "Anderson", assigned_to: current_user.id)
+      account_2 = FactoryGirl.create(:account, name: "Wilson", assigned_to: current_user.id)
+      account_3 = FactoryGirl.create(:account, name: "Triple", assigned_to: current_user.id)
+      account_4 = FactoryGirl.create(:account, name: "Double", assigned_to: nil, user_id: current_user.id)
+
+      FactoryGirl.create(:account, name: "Someone else's Account", assigned_to: FactoryGirl.create(:user).id)
+      FactoryGirl.create(:account, name: "Not my account", assigned_to: FactoryGirl.create(:user).id)
+
+      get :index
+      expect(assigns[:my_accounts]).to eq([account_1, account_4, account_3, account_2])
+    end
+  end
+
+  # GET /home/options                                                      AJAX
+  #----------------------------------------------------------------------------
+  describe "responding to GET options" do
+    before(:each) do
+      require_user
+    end
+
+    it "should assign instance variables for user preferences" do
+      @asset = FactoryGirl.create(:preference, user: current_user, name: "activity_asset", value: Base64.encode64(Marshal.dump("tasks")))
+      @user = FactoryGirl.create(:preference, user: current_user, name: "activity_user", value: Base64.encode64(Marshal.dump("Billy Bones")))
+      @duration = FactoryGirl.create(:preference, user: current_user, name: "activity_duration", value: Base64.encode64(Marshal.dump("two days")))
+
+      xhr :get, :options
+      expect(assigns[:asset]).to eq("tasks")
+      expect(assigns[:user]).to eq("Billy Bones")
+      expect(assigns[:duration]).to eq("two days")
+      expect(assigns[:all_users]).to eq(User.order(:first_name, :last_name).to_a)
+    end
+
+    it "should not assign instance variables when hiding options" do
+      xhr :get, :options, cancel: "true"
+      expect(assigns[:asset]).to eq(nil)
+      expect(assigns[:user]).to eq(nil)
+      expect(assigns[:duration]).to eq(nil)
+      expect(assigns[:all_users]).to eq(nil)
+    end
+  end
+
+  # GET /home/redraw                                                       AJAX
+  #----------------------------------------------------------------------------
+  describe "responding to GET redraw" do
+    before(:each) do
+      require_user
+    end
+
+    it "should save user selected options" do
+      xhr :get, :redraw, asset: "tasks", user: "Billy Bones", duration: "two days"
+      expect(current_user.pref[:activity_asset]).to eq("tasks")
+      expect(current_user.pref[:activity_user]).to eq("Billy Bones")
+      expect(current_user.pref[:activity_duration]).to eq("two days")
+    end
+
+    it "should get a list of activities" do
+      @activity = FactoryGirl.create(:version, item: FactoryGirl.create(:account, user: current_user))
+      expect(controller).to receive(:get_activities).once.and_return([@activity])
+
+      get :index
+      expect(assigns[:activities]).to eq([@activity])
+    end
+  end
+
+  # GET /home/toggle                                                       AJAX
+  #----------------------------------------------------------------------------
+  describe "responding to GET toggle" do
+    it "should toggle expand/collapse state of form section in the session (delete existing session key)" do
+      session[:hello] = "world"
+
+      xhr :get, :toggle, id: "hello"
+      expect(session.keys).not_to include(:hello)
+    end
+
+    it "should toggle expand/collapse state of form section in the session (save new session key)" do
+      session.delete(:hello)
+
+      xhr :get, :toggle, id: "hello"
+      expect(session[:hello]).to eq(true)
+    end
+  end
+
+  describe "activity_user" do
+    before(:each) do
+      @user = double(User, id: 1, is_a?: true)
+      @cur_user = double(User)
+    end
+
+    it "should find a user by email" do
+      allow(@cur_user).to receive(:pref).and_return(activity_user: 'billy@example.com')
+      controller.instance_variable_set(:@current_user, @cur_user)
+      expect(User).to receive(:where).with(email: 'billy@example.com').and_return([@user])
+      expect(controller.send(:activity_user)).to eq(1)
+    end
+
+    it "should find a user by first name or last name" do
+      allow(@cur_user).to receive(:pref).and_return(activity_user: 'Billy')
+      controller.instance_variable_set(:@current_user, @cur_user)
+      expect(User).to receive(:where).with(first_name: 'Billy').and_return([@user])
+      expect(User).to receive(:where).with(last_name: 'Billy').and_return([@user])
+      expect(controller.send(:activity_user)).to eq(1)
+    end
+
+    it "should find a user by first name and last name" do
+      allow(@cur_user).to receive(:pref).and_return(activity_user: 'Billy Elliot')
+      controller.instance_variable_set(:@current_user, @cur_user)
+      expect(User).to receive(:where).with(first_name: 'Billy', last_name: "Elliot").and_return([@user])
+      expect(User).to receive(:where).with(first_name: 'Elliot', last_name: "Billy").and_return([@user])
+      expect(controller.send(:activity_user)).to eq(1)
+    end
+
+    it "should return nil when 'all_users' is specified" do
+      allow(@cur_user).to receive(:pref).and_return(activity_user: 'all_users')
+      controller.instance_variable_set(:@current_user, @cur_user)
+      expect(User).not_to receive(:where)
+      expect(controller.send(:activity_user)).to eq(nil)
+    end
+  end
+
+  describe "timeline" do
+    before(:each) do
+      require_user
+    end
+
+    it "should collapse all comments and emails on a specific contact" do
+      comment = double(Comment)
+      expect(Comment).to receive(:find).with("1").and_return(comment)
+      expect(comment).to receive(:update_attribute).with(:state, 'Collapsed')
+      xhr :get, :timeline, type: "comment", id: "1", state: "Collapsed"
+    end
+
+    it "should expand all comments and emails on a specific contact" do
+      comment = double(Comment)
+      expect(Comment).to receive(:find).with("1").and_return(comment)
+      expect(comment).to receive(:update_attribute).with(:state, 'Expanded')
+      xhr :get, :timeline, type: "comment", id: "1", state: "Expanded"
+    end
+
+    it "should not do anything when state neither Expanded nor Collapsed" do
+      comment = double(Comment)
+      expect(Comment).not_to receive(:find).with("1")
+      xhr :get, :timeline, type: "comment", id: "1", state: "Explode"
+    end
+
+    it "should collapse all comments and emails on Contact" do
+      where_stub = double
+      expect(where_stub).to receive(:update_all).with(state: "Collapsed")
+      expect(Comment).to receive(:where).and_return(where_stub)
+      xhr :get, :timeline, id: "1,2,3,4+", state: "Collapsed"
+    end
+
+    it "should not allow an arbitary state (sanitizes input)" do
+      where_stub = double
+      expect(where_stub).to receive(:update_all).with(state: "Expanded")
+      expect(Comment).to receive(:where).and_return(where_stub)
+      xhr :get, :timeline, id: "1,2,3,4+", state: "Expanded"
+    end
+
+    it "should not update an arbitary model (sanitizes input)" do
+      where_stub = double
+      expect(where_stub).to receive(:update_all).with(state: "Expanded")
+      expect(Comment).to receive(:where).and_return(where_stub)
+      xhr :get, :timeline, id: "1,2,3,4+", state: "Expanded"
+    end
+  end
+end

data/spec/controllers/lists_controller_spec.rb

@@ -0,0 +1,9 @@
+# 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 ListsController do
+end

data/spec/controllers/passwords_controller_spec.rb

@@ -0,0 +1,30 @@
+# 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 PasswordsController do
+  let(:user) { FactoryGirl.build(:user) }
+
+  describe "update" do
+    before(:each) do
+      allow(User).to receive(:find_using_perishable_token).and_return(user)
+    end
+
+    it "should accept non-blank passwords" do
+      password = "password"
+      expect(user).to receive(:update_attributes).and_return(true)
+      put :update, id: 1, user: { password: password, password_confirmation: password }
+      expect(response).to redirect_to(profile_url)
+    end
+
+    it "should not accept blank passwords" do
+      password = "    "
+      expect(user).not_to receive(:update_attributes)
+      put :update, id: 1, user: { password: password, password_confirmation: password }
+      expect(response).to render_template('edit')
+    end
+  end
+end

data/spec/controllers/tasks_controller_spec.rb

@@ -0,0 +1,512 @@
+# 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 File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe TasksController do
+  def update_sidebar
+    @task_total = { key: :value, pairs: :etc }
+    allow(Task).to receive(:totals).and_return(@task_total)
+  end
+
+  def produce_tasks(user, view)
+    settings = (view != "completed" ? Setting.task_bucket : Setting.task_completed)
+
+    settings.inject({}) do | hash, due |
+      hash[due] ||= []
+      if Date.tomorrow == Date.today.end_of_week && due == :due_tomorrow
+        due = :due_this_week
+        hash[due] ||= []
+      end
+      hash[due] << case view
+      when "pending"
+        FactoryGirl.create(:task, user: user, bucket: due.to_s)
+      when "assigned"
+        FactoryGirl.create(:task, user: user, bucket: due.to_s, assigned_to: 1)
+      when "completed"
+        completed_at = case due
+          when :completed_today
+            Date.yesterday + 1.day
+          when :completed_yesterday
+            Date.yesterday
+          when :completed_last_week
+            Date.today.beginning_of_week - 7.days
+          when :completed_this_month
+            Date.today.beginning_of_month
+          when :completed_last_month
+            Date.today.beginning_of_month - 1.day
+        end
+        FactoryGirl.create(:task, user: user, bucket: due.to_s, completed_at: completed_at)
+      end
+      hash
+    end
+  end
+
+  before(:each) do
+    require_user
+    set_current_tab(:tasks)
+  end
+
+  # GET /tasks
+  # GET /tasks.xml
+  #----------------------------------------------------------------------------
+  describe "responding to GET index" do
+    before do
+      update_sidebar
+      @timezone, Time.zone = Time.zone, 'UTC'
+    end
+
+    after do
+      Time.zone = @timezone
+    end
+
+    TASK_STATUSES.each do |view|
+      it "should expose all tasks as @tasks and render [index] template for #{view} view" do
+        @tasks = produce_tasks(current_user, view)
+
+        get :index, view: view
+
+        expect(assigns[:tasks].keys.map(&:to_sym) - @tasks.keys).to eq([])
+        expect(assigns[:tasks].values.flatten - @tasks.values.flatten).to eq([])
+        expect(assigns[:task_total].symbolize_keys).to eq(@task_total)
+        expect(response).to render_template("tasks/index")
+      end
+
+      it "should render all tasks as JSON for #{view} view" do
+        @tasks = produce_tasks(current_user, view)
+        get :index, view: view, format: :json
+
+        expect(assigns[:tasks].keys.map(&:to_sym) - @tasks.keys).to eq([])
+        expect(assigns[:tasks].values.flatten - @tasks.values.flatten).to eq([])
+        hash = ActiveSupport::JSON.decode(response.body)
+
+        hash.keys.each do |key|
+          hash[key].each do |attr|
+            task = Task.new(attr["task"])
+            expect(task).to be_instance_of(Task)
+            expect(task.valid?).to eq(true)
+          end
+        end
+      end
+
+      it "should render all tasks as xml for #{view} view" do
+        @tasks = produce_tasks(current_user, view)
+        get :index, view: view, format: :xml
+
+        expect(assigns[:tasks].keys.map(&:to_sym) - @tasks.keys).to eq([])
+        expect(assigns[:tasks].values.flatten - @tasks.values.flatten).to eq([])
+        hash = Hash.from_xml(response.body)
+        hash["hash"].keys.each do |key|
+          hash["hash"][key].each do |attr|
+            task = Task.new(attr)
+            expect(task).to be_instance_of(Task)
+            expect(task.valid?).to eq(true)
+          end
+        end
+      end
+    end
+  end
+
+  # GET /tasks/1
+  # GET /tasks/1.xml
+  #----------------------------------------------------------------------------
+  describe "responding to GET show" do
+    TASK_STATUSES.each do |view|
+      it "should render the requested task as JSON for #{view} view" do
+        allow(Task).to receive_message_chain(:tracked_by, :find).and_return(task = double("Task"))
+        expect(task).to receive(:to_json).and_return("generated JSON")
+
+        request.env["HTTP_ACCEPT"] = "application/json"
+        get :show, id: 42, view: "pending"
+        expect(response.body).to eq("generated JSON")
+      end
+
+      it "should render the requested task as xml for #{view} view" do
+        allow(Task).to receive_message_chain(:tracked_by, :find).and_return(task = double("Task"))
+        expect(task).to receive(:to_xml).and_return("generated XML")
+
+        request.env["HTTP_ACCEPT"] = "application/xml"
+        get :show, id: 42, view: "pending"
+        expect(response.body).to eq("generated XML")
+      end
+    end
+  end
+
+  # GET /tasks/new
+  # GET /tasks/new.xml                                                     AJAX
+  #----------------------------------------------------------------------------
+  describe "responding to GET new" do
+    it "should expose a new task as @task and render [new] template" do
+      account = FactoryGirl.create(:account, user: current_user)
+      @task = FactoryGirl.build(:task, user: current_user, asset: account)
+      allow(Task).to receive(:new).and_return(@task)
+      @bucket = Setting.unroll(:task_bucket)[1..-1] << ["On Specific Date...", :specific_time]
+      @category = Setting.unroll(:task_category)
+
+      xhr :get, :new
+      expect(assigns[:task]).to eq(@task)
+      expect(assigns[:bucket]).to eq(@bucket)
+      expect(assigns[:category]).to eq(@category)
+      expect(response).to render_template("tasks/new")
+    end
+
+    it "should find related asset when necessary" do
+      @asset = FactoryGirl.create(:account, id: 42)
+
+      xhr :get, :new, related: "account_42"
+      expect(assigns[:asset]).to eq(@asset)
+      expect(response).to render_template("tasks/new")
+    end
+
+    describe "(when creating related task)" do
+      it "should redirect to parent asset's index page with the message if parent asset got deleted" do
+        @account = FactoryGirl.create(:account)
+        @account.destroy
+
+        xhr :get, :new, related: "account_#{@account.id}"
+        expect(flash[:warning]).not_to eq(nil)
+        expect(response.body).to eq('window.location.href = "/accounts";')
+      end
+
+      it "should redirect to parent asset's index page with the message if parent asset got protected" do
+        @account = FactoryGirl.create(:account, access: "Private")
+
+        xhr :get, :new, related: "account_#{@account.id}"
+        expect(flash[:warning]).not_to eq(nil)
+        expect(response.body).to eq('window.location.href = "/accounts";')
+      end
+    end
+  end
+
+  # GET /tasks/1/edit                                                      AJAX
+  #----------------------------------------------------------------------------
+  describe "responding to GET edit" do
+    it "should expose the requested task as @task and render [edit] template" do
+      @asset = FactoryGirl.create(:account, user: current_user)
+      @task = FactoryGirl.create(:task, user: current_user, asset: @asset)
+      @bucket = Setting.unroll(:task_bucket)[1..-1] << ["On Specific Date...", :specific_time]
+      @category = Setting.unroll(:task_category)
+
+      xhr :get, :edit, id: @task.id
+      expect(assigns[:task]).to eq(@task)
+      expect(assigns[:bucket]).to eq(@bucket)
+      expect(assigns[:category]).to eq(@category)
+      expect(assigns[:asset]).to eq(@asset)
+      expect(response).to render_template("tasks/edit")
+    end
+
+    it "should find previously open task when necessary" do
+      @task = FactoryGirl.create(:task, user: current_user)
+      @previous = FactoryGirl.create(:task, id: 999, user: current_user)
+
+      xhr :get, :edit, id: @task.id, previous: 999
+      expect(assigns[:task]).to eq(@task)
+      expect(assigns[:previous]).to eq(@previous)
+      expect(response).to render_template("tasks/edit")
+    end
+
+    describe "(task got deleted or reassigned)" do
+      it "should reload current page with the flash message if the task got deleted" do
+        @task = FactoryGirl.create(:task, user: FactoryGirl.create(:user), assignee: current_user)
+        @task.destroy
+
+        xhr :get, :edit, id: @task.id
+        expect(flash[:warning]).not_to eq(nil)
+        expect(response.body).to eq("window.location.reload();")
+      end
+
+      it "should reload current page with the flash message if the task got reassigned" do
+        @task = FactoryGirl.create(:task, user: FactoryGirl.create(:user), assignee: FactoryGirl.create(:user))
+
+        xhr :get, :edit, id: @task.id
+        expect(flash[:warning]).not_to eq(nil)
+        expect(response.body).to eq("window.location.reload();")
+      end
+    end
+
+    describe "(previous task got deleted or reassigned)" do
+      before(:each) do
+        @task = FactoryGirl.create(:task, user: current_user)
+        @previous = FactoryGirl.create(:task, user: FactoryGirl.create(:user), assignee: current_user)
+      end
+
+      it "should notify the view if previous task got deleted" do
+        @previous.destroy
+
+        xhr :get, :edit, id: @task.id, previous: @previous.id
+        expect(flash[:warning]).to eq(nil) # no warning, just silently remove the div
+        expect(assigns[:previous]).to eq(@previous.id)
+        expect(response).to render_template("tasks/edit")
+      end
+
+      it "should notify the view if previous task got reassigned" do
+        @previous.update_attribute(:assignee, FactoryGirl.create(:user))
+
+        xhr :get, :edit, id: @task.id, previous: @previous.id
+        expect(flash[:warning]).to eq(nil)
+        expect(assigns[:previous]).to eq(@previous.id)
+        expect(response).to render_template("tasks/edit")
+      end
+    end
+  end
+
+  # POST /tasks
+  # POST /tasks.xml                                                        AJAX
+  #----------------------------------------------------------------------------
+  describe "responding to POST create" do
+    describe "with valid params" do
+      it "should expose a newly created task as @task and render [create] template" do
+        @task = FactoryGirl.build(:task, user: current_user)
+        allow(Task).to receive(:new).and_return(@task)
+
+        xhr :post, :create, task: { name: "Hello world" }
+        expect(assigns(:task)).to eq(@task)
+        expect(assigns(:view)).to eq("pending")
+        expect(assigns[:task_total]).to eq(nil)
+        expect(response).to render_template("tasks/create")
+      end
+
+      ["", "?view=pending", "?view=assigned", "?view=completed"].each do |view|
+        it "should update tasks sidebar when [create] is being called from [/tasks#{view}] page" do
+          @task = FactoryGirl.build(:task, user: current_user)
+          allow(Task).to receive(:new).and_return(@task)
+
+          request.env["HTTP_REFERER"] = "http://localhost/tasks#{view}"
+          xhr :post, :create, task: { name: "Hello world" }
+          expect(assigns[:task_total]).to be_an_instance_of(HashWithIndifferentAccess)
+        end
+      end
+    end
+
+    describe "with invalid params" do
+      it "should expose a newly created but unsaved task as @lead and still render [create] template" do
+        @task = FactoryGirl.build(:task, name: nil, user: current_user)
+        allow(Task).to receive(:new).and_return(@task)
+
+        xhr :post, :create, task: {}
+        expect(assigns(:task)).to eq(@task)
+        expect(assigns(:view)).to eq("pending")
+        expect(assigns[:task_total]).to eq(nil)
+        expect(response).to render_template("tasks/create")
+      end
+    end
+  end
+
+  # PUT /tasks/1
+  # PUT /tasks/1.xml                                                       AJAX
+  #----------------------------------------------------------------------------
+  describe "responding to PUT update" do
+    describe "with valid params" do
+      it "should update the requested task, expose it as @task, and render [update] template" do
+        @task = FactoryGirl.create(:task, name: "Hi", user: current_user)
+
+        xhr :put, :update, id: @task.id, task: { name: "Hello" }
+        expect(@task.reload.name).to eq("Hello")
+        expect(assigns(:task)).to eq(@task)
+        expect(assigns(:view)).to eq("pending")
+        expect(assigns[:task_total]).to eq(nil)
+        expect(response).to render_template("tasks/update")
+      end
+
+      ["", "?view=pending", "?view=assigned", "?view=completed"].each do |view|
+        it "should update tasks sidebar when [update] is being called from [/tasks#{view}] page" do
+          @task = FactoryGirl.create(:task, name: "Hi", user: current_user)
+
+          request.env["HTTP_REFERER"] = "http://localhost/tasks#{view}"
+          xhr :put, :update, id: @task.id, task: { name: "Hello" }
+          expect(assigns[:task_total]).to be_an_instance_of(HashWithIndifferentAccess)
+        end
+      end
+    end
+
+    describe "with invalid params" do
+      it "should not update the task, but still expose it as @task and render [update] template" do
+        @task = FactoryGirl.create(:task, name: "Hi", user: current_user)
+
+        xhr :put, :update, id: @task.id, task: { name: nil }
+        expect(@task.reload.name).to eq("Hi")
+        expect(assigns(:task)).to eq(@task)
+        expect(assigns(:view)).to eq("pending")
+        expect(assigns[:task_total]).to eq(nil)
+        expect(response).to render_template("tasks/update")
+      end
+    end
+
+    describe "task got deleted or reassigned" do
+      it "should reload current page with the flash message if the task got deleted" do
+        @task = FactoryGirl.create(:task, user: FactoryGirl.create(:user), assignee: current_user)
+        @task.destroy
+
+        xhr :put, :update, id: @task.id, task: { name: "Hello" }
+        expect(flash[:warning]).not_to eq(nil)
+        expect(response.body).to eq("window.location.reload();")
+      end
+
+      it "should reload current page with the flash message if the task got reassigned" do
+        @task = FactoryGirl.create(:task, user: FactoryGirl.create(:user), assignee: FactoryGirl.create(:user))
+
+        xhr :put, :update, id: @task.id, task: { name: "Hello" }
+        expect(flash[:warning]).not_to eq(nil)
+        expect(response.body).to eq("window.location.reload();")
+      end
+    end
+  end
+
+  # DELETE /tasks/1
+  # DELETE /tasks/1.xml                                                    AJAX
+  #----------------------------------------------------------------------------
+  describe "responding to DELETE destroy" do
+    it "should destroy the requested task and render [destroy] template" do
+      @task = FactoryGirl.create(:task, user: current_user)
+
+      xhr :delete, :destroy, id: @task.id, bucket: "due_asap"
+      expect(assigns(:task)).to eq(@task)
+      expect(assigns(:view)).to eq("pending")
+      expect(assigns[:task_total]).to eq(nil)
+      expect(response).to render_template("tasks/destroy")
+    end
+
+    ["", "?view=pending", "?view=assigned", "?view=completed"].each do |view|
+      it "should update sidebar when [destroy] is being called from [/tasks#{view}]" do
+        @task = FactoryGirl.create(:task, user: current_user)
+
+        request.env["HTTP_REFERER"] = "http://localhost/tasks#{view}"
+        xhr :delete, :destroy, id: @task.id, bucket: "due_asap"
+        expect(assigns[:task_total]).to be_an_instance_of(HashWithIndifferentAccess)
+      end
+    end
+
+    it "should not update sidebar when [destroy] is being called from asset page" do
+      @task = FactoryGirl.create(:task, user: current_user)
+
+      xhr :delete, :destroy, id: @task.id
+      expect(assigns[:task_total]).to eq(nil)
+    end
+
+    describe "task got deleted or reassigned" do
+      it "should reload current page with the flash message if the task got deleted" do
+        @task = FactoryGirl.create(:task, user: FactoryGirl.create(:user), assignee: current_user)
+        @task.destroy
+
+        xhr :delete, :destroy, id: @task.id
+        expect(flash[:warning]).not_to eq(nil)
+        expect(response.body).to eq("window.location.reload();")
+      end
+
+      it "should reload current page with the flash message if the task got reassigned" do
+        @task = FactoryGirl.create(:task, user: FactoryGirl.create(:user), assignee: FactoryGirl.create(:user))
+
+        xhr :delete, :destroy, id: @task.id
+        expect(flash[:warning]).not_to eq(nil)
+        expect(response.body).to eq("window.location.reload();")
+      end
+    end
+  end
+
+  # PUT /tasks/1/complete
+  # PUT /leads/1/complete.xml                                              AJAX
+  #----------------------------------------------------------------------------
+  describe "responding to PUT complete" do
+    it "should change task status, expose task as @task, and render [complete] template" do
+      @task = FactoryGirl.create(:task, completed_at: nil, user: current_user)
+
+      xhr :put, :complete, id: @task.id
+      expect(@task.reload.completed_at).not_to eq(nil)
+      expect(assigns[:task]).to eq(@task)
+      expect(assigns[:task_total]).to eq(nil)
+      expect(response).to render_template("tasks/complete")
+    end
+
+    it "should change task status, expose task as @task, and render [complete] template where task.bucket = 'specific_time'" do
+      @task = FactoryGirl.create(:task, completed_at: nil, user: current_user, bucket: "specific_time", calendar: "01/01/2010 1:00 AM")
+
+      xhr :put, :complete, id: @task.id
+      expect(@task.reload.completed_at).not_to eq(nil)
+      expect(assigns[:task]).to eq(@task)
+      expect(assigns[:task_total]).to eq(nil)
+      expect(response).to render_template("tasks/complete")
+    end
+
+    it "should change update tasks sidebar if bucket is not empty" do
+      @task = FactoryGirl.create(:task, completed_at: nil, user: current_user)
+
+      xhr :put, :complete, id: @task.id, bucket: "due_asap"
+      expect(assigns[:task_total]).to be_an_instance_of(HashWithIndifferentAccess)
+    end
+
+    describe "task got deleted or reassigned" do
+      it "should reload current page with the flash message if the task got deleted" do
+        @task = FactoryGirl.create(:task, user: FactoryGirl.create(:user), assignee: current_user)
+        @task.destroy
+
+        xhr :put, :complete, id: @task.id
+        expect(flash[:warning]).not_to eq(nil)
+        expect(response.body).to eq("window.location.reload();")
+      end
+
+      it "should reload current page with the flash message if the task got reassigned" do
+        @task = FactoryGirl.create(:task, user: FactoryGirl.create(:user), assignee: FactoryGirl.create(:user))
+
+        xhr :put, :complete, id: @task.id
+        expect(flash[:warning]).not_to eq(nil)
+        expect(response.body).to eq("window.location.reload();")
+      end
+    end
+  end
+
+  # PUT /tasks/1/complete
+  # PUT /leads/1/complete.xml                                              AJAX
+  #----------------------------------------------------------------------------
+  describe "responding to PUT uncomplete" do
+    it "should change task status, expose task as @task, and render template" do
+      @task = FactoryGirl.create(:task, completed_at: Time.now, user: current_user)
+
+      xhr :put, :uncomplete, id: @task.id
+      expect(@task.reload.completed_at).to eq(nil)
+      expect(assigns[:task]).to eq(@task)
+      expect(assigns[:task_total]).not_to eq(nil)
+      expect(response).to render_template("tasks/uncomplete")
+    end
+
+    describe "task got deleted" do
+      it "should reload current page with the flash message if the task got deleted" do
+        @task = FactoryGirl.create(:task, user: FactoryGirl.create(:user), assignee: current_user, completed_at: Time.now)
+        @task.destroy
+
+        xhr :put, :uncomplete, id: @task.id
+        expect(flash[:warning]).not_to eq(nil)
+        expect(response.body).to eq("window.location.reload();")
+      end
+    end
+  end
+
+  # Ajax request to filter out a list of tasks.                            AJAX
+  #----------------------------------------------------------------------------
+  describe "responding to GET filter" do
+    TASK_STATUSES.each do |view|
+      it "should remove a filter from session and render [filter] template for #{view} view" do
+        name = "filter_by_task_#{view}"
+        session[name] = "due_asap,due_today,due_tomorrow"
+
+        xhr :get, :filter, filter: "due_asap", view: view
+        expect(session[name]).not_to include("due_asap")
+        expect(session[name]).to include("due_today")
+        expect(session[name]).to include("due_tomorrow")
+        expect(response).to render_template("tasks/filter")
+      end
+
+      it "should add a filter from session and render [filter] template for #{view} view" do
+        name = "filter_by_task_#{view}"
+        session[name] = "due_today,due_tomorrow"
+
+        xhr :get, :filter, checked: "true", filter: "due_asap", view: view
+        expect(session[name]).to include("due_asap")
+        expect(session[name]).to include("due_today")
+        expect(session[name]).to include("due_tomorrow")
+        expect(response).to render_template("tasks/filter")
+      end
+    end
+  end
+end