require File.dirname(__FILE__) + '/../test_helper'

class NewslettersControllerTest < ActionController::TestCase
  # Replace this with your real tests.

  # when routes handling do
  def test_shoud_map_get_newsletter_to_index_action
    assert_recognizes({ :controller => 'newsletters', :action => 'index' }, { :method => :get, :path => '/newsletters' })
  end

  def test_should_map_post_newsletter_to_create_action
    assert_recognizes({ :controller => 'newsletters', :action => 'create'}, { :method => :post, :path => '/newsletters/create' })
  end

  def test_should_map_get_newsletter_new_to_new_action
    assert_recognizes({ :controller => 'newsletters', :action => 'new'}, {:method => :get, :path => '/newsletters/new'})
  end

  def test_should_map_get_newsletter_preview_to_preview_action
    assert_recognizes({ :controller => 'newsletters',
                        :action => 'preview',
                        :id => '1' },
                      { :method => :get,
                        :path => '/newsletters/preview/1' })
  end

  # end

  # when user is authenticated
  def before_each_authenticated
    login_user!
  end

    # and authorized
    def before_each_authorized
      before_each_authenticated
      @current_user.expects(:current_role).returns('iBridgeAdmin').at_least_once
    end

      # and GET '/newsletter' is handled
      def before_each_get_newsletter
        before_each_authorized
        Newsletter.expects(:find).with(:all).returns([])
        get :index
      end

        # it should render the newsletters/index template
        def test_should_render_newsletters_index_template_when_user_is_authorized_on_index_action
          before_each_get_newsletter
          assert_response :success
          assert_template 'newsletters/index'
        end
        # it should assigns all the newsletters in the response
        def test_should_assigns_all_the_newsletter_in_the_response_when_user_is_authorized_on_index_action
          before_each_get_newsletter
          assert_not_nil assigns(:newsletters)
        end

      # and GET '/newsletter/new' is handled
      def before_each_get_newsletter_new
        before_each_authorized
        get :new
      end

        # it should render the newsletters/new template
        def test_should_render_newsletters_new_template_when_user_is_authorized_on_new_action
          before_each_get_newsletter_new
          assert_response :success
          assert_template 'newsletters/new'
        end
        # it should assign a new newsletter instance in the response
        def test_should_assign_a_new_newsletter_instance_in_the_response_when_user_is_authorized_on_new_action
          before_each_get_newsletter_new
          assert_not_nil assigns(:newsletter)
        end

      # and POST '/newsletter/create' is handled
        # and the newsletter is valid
        def before_each_newsletter_valid_on_create
          before_each_authorized
          @newsletter = stub(valid_newsletter_attributes(:save => true))
          Newsletter.expects(:new).with({}).returns(@newsletter)
          post :create, :newsletter => {}
        end

          # it should redirect to the index action
          def test_should_redirect_to_index_action_when_user_is_authorized_and_newsletter_valid_on_create_action
            before_each_newsletter_valid_on_create
            assert_response :redirect
            assert_redirected_to :controller => 'newsletters', :action => 'index'
          end
          # it should assign a flash notice
          def test_should_assign_a_flash_notice_when_user_is_authorized_and_newsletter_valid_on_create_action
            before_each_newsletter_valid_on_create
            assert_not_nil flash[:notice]
            assert_equal "The Newsletter was created successfuly", flash[:notice]
          end

        # but the newsletter is not valid
        def before_each_newsletter_invalid_on_create
          before_each_authorized
          @newsletter = stub('newsletter', valid_newsletter_attributes(:save => false, :errors => stub('errors', :count => 0)))
          Newsletter.expects(:new).with({}).returns(@newsletter)
          post :create, :newsletter => {}
        end

          # it should render the new template
          def test_should_render_new_template_when_user_is_authorized_and_newsletter_invalid_on_creation_action
            before_each_newsletter_invalid_on_create
            assert_response :success
            assert_template 'newsletters/new'
          end


      # and GET '/newsletters/preview/<id>' is handled
      def before_each_newsletter_preview
        before_each_authorized
        @newsletter = stub('newsletter', valid_newsletter_attributes)
        Newsletter.expects(:find).with('5').returns(@newsletter)
        get :preview, :id => 5
      end

        # it should render preview template
        def test_should_render_preview_template_when_user_is_authorzied_on_preview_action
          before_each_newsletter_preview
          assert_response :success
          assert_template 'newsletters/preview'
        end


    # but is not authorized
      # it should redirect to the login path
      def test_should_redirect_to_login_path_when_no_authorized
        before_each_authenticated
        get :index
        assert_response :redirect
        assert_redirected_to :controller => 'user', :action => 'login'
      end

      # it should assign a flash notice
      def test_should_assign_flash_notice_when_no_authorized
        before_each_authenticated
        get :index
        assert_not_nil flash[:warning]
      end

  # end

  protected

  def login_user!(params = {})
    @current_user = stub(valid_user_attributes(params))
    @controller.expects(:current_user).returns(@current_user).at_least_once
  end

end