require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')

describe Admin::UsersController do
  extend RulesEngineMacros
  extend RulesEngineUsersMacros
  
  before (:each) do
    controller.stub!(:admin_access_required).and_return(true)
    controller.instance_eval { flash.stub!(:sweep) }
  end
  
  describe "index" do
    it_should_require_admin_access(:index)
    
    it "should get the list of users" do
      users = [1, 2]
      User.should_receive(:paginate).and_return(users)
      get :index
      assigns[:users].should == users
    end

    describe "sorting the results" do
      it "should sort by full_name by default" do
        User.should_receive(:order_full_name).and_return(User)
        get :index
      end
      
      it "should sort by full_name when query_type = full_name" do
        User.should_receive(:order_full_name).and_return(User)
        get :index, :query_type => "full_name"
      end

      it "should sort by login when query_type = login" do
        User.should_receive(:order_login).and_return(User)
        get :index, :query_type => "login"
      end

      it "should sort by email when query_type = email" do
        User.should_receive(:order_email).and_return(User)
        get :index, :query_type => "email"
      end
    end
    
    describe "filtering the results" do
      it "should sort by full_name when query_type = full_name and query set" do
        User.should_receive(:by_ge_full_name).with('mock_query').and_return(User)
        get :index, :query_type => "full_name", :query => "mock_query"
      end

      it "should sort by login when query_type = login and query set" do
        User.should_receive(:by_ge_login).with('mock_query').and_return(User)
        get :index, :query_type => "login", :query => "mock_query"
      end

      it "should sort by email when query_type = email and query set" do
        User.should_receive(:by_ge_email).with('mock_query').and_return(User)
        get :index, :query_type => "email", :query => "mock_query"
      end
    end
  end
  
  describe "show" do
    it_should_require_admin_access(:show)
    
    it "should get the user record with the ID" do
      User.should_receive(:find).with("123")
      get :show, :id => 123
    end
  end
    
  describe "new" do
    it_should_require_admin_access(:new)
    
    it "should provide a fresh user object" do
      User.should_receive :new
      get :new
    end
  end
    
  describe "create" do
    it_should_require_admin_access(:create)
    
    before do
      @user = mock_model(User, :save => false)
      User.stub!(:new).and_return(@user) 
    end
    
    describe "creation failed" do
      it "should render the 'new' template" do
        post :create, :user => { :key => "value" }
        response.should render_template(:new)
      end
    end
    
    describe "user created" do
      before do
      @user.stub!(:save).and_return(true)
      end
      
      it "should save the user" do
        @user.should_receive :save
        post :create, :user => { :key => "value" }
      end
      
      it "should display a flash success message" do
        post :create, :user => { :key => "value" }
        flash[:success].should_not be_blank
      end
      
      it "should redirect to the show user page" do
        post :create, :user => { :key => "value" }
        response.should redirect_to(admin_user_path(@user))
      end
    end
  end
  
  describe "edit" do
    it_should_require_admin_access(:edit)
    
    it "should get the user with the specified ID" do
      User.should_receive(:find).with "123"
      put :edit, :id => 123
    end
  end
  
  describe "update" do
    it_should_require_admin_access(:update)
    
    before do
      @user = mock_model(User, :update_attributes => false)
      User.stub!(:find).and_return(@user) 
    end
  
    describe "update failed" do
      it "should render the edit template on failure" do
        put :update, :id => 1, :user => { :key => "value" }
        response.should render_template(:edit)
      end
    end
  
    describe "success" do
      before do
        @user.stub!(:update_attributes).and_return(true)
      end
    
        it "should save the user" do
          @user.should_receive(:update_attributes).with("key" => "value")
          put :update, :id => 1, :user => { :key => "value" }
        end
      
        it "should display a flash success message" do
          put :update, :id => 1, :user => { :key => "value" }
          flash[:success].should_not be_blank
        end
      
        it "should redirect to the profile of the user" do
          put :update, :id => 1, :user => { :key => "value" }
          response.should redirect_to(admin_user_path(@user))
        end
    end
  end

  describe "destroy" do
    it_should_require_admin_access(:destroy)
    
    before do
      @user = mock_model(User, :destroy => true)
      User.stub!(:find).and_return(@user) 
    end
  
    it "should find the user with the given ID" do
      User.should_receive(:find).with("123").and_return @user
      delete :destroy, :id => 123 
    end
  
    it "should destroy the found user" do
      @user.should_receive :destroy
      delete :destroy, :id => 123 
    end
  
    it "should redirect to the users list after deletion" do
      delete :destroy, :id => 123 
      response.should redirect_to(admin_users_path)
    end
  
    it "should show a flash sucess message" do
      delete :destroy, :id => 123 
      flash[:success].should_not be_blank
    end
  end
end