require 'spec_helper'
require 'cape/dsl'
require 'cape/dsl_deprecated'
require 'cape/capistrano'
require 'cape/core_ext/hash'
require 'cape/core_ext/symbol'
require 'cape/rake'
require 'cape/xterm'

describe Cape::DSLDeprecated do
  subject(:dsl) do
    Object.new.tap do |o|
      o.extend Cape::DSL
      o.extend dsl_module
    end
  end

  let(:dsl_module) { described_class }

  let(:capistrano) { double(Cape::Capistrano).as_null_object }

  let(:rake) { double(Cape::Rake).as_null_object }

  let(:task_expression) { 'task:expression' }

  before :each do
    allow(Cape::Capistrano).to receive(:new).and_return(capistrano)
    allow(Cape::Rake      ).to receive(:new).and_return(rake)
    dsl.deprecation.stream = StringIO.new
  end

  describe '#each_rake_task' do
    def do_each_rake_task(&block)
      dsl.each_rake_task(task_expression, &block)
    end

    it 'delegates to Rake#each_task' do
      expect(rake).to receive(:each_task).
                      with(task_expression).
                      and_yield({:name => task_expression})
      do_each_rake_task do |t|
        expect(t).to eq(:name => task_expression)
      end
    end

    it 'returns itself' do
      expect(do_each_rake_task).to eq(dsl)
    end
  end

  describe '#mirror_rake_tasks' do
    before :each do
      allow(rake).to receive(:each_task).and_yield({:name => task_expression})
      allow(dsl ).to receive(:raise_unless_capistrano)
    end

    def do_mirror_rake_tasks(*arguments, &block)
      dsl.mirror_rake_tasks(*arguments, &block)
    end

    let(:deprecation_preamble) {
      Cape::XTerm.bold_and_foreground_red('*** DEPRECATED:') + ' '
    }

    describe 'with two scalar arguments --' do
      specify do
        expect {
          do_mirror_rake_tasks task_expression, task_expression
        }.to raise_error(ArgumentError,
                         'wrong number of arguments (2 for 0 or 1, plus ' +
                         'an options hash)')
      end
    end

    shared_examples_for "a successful call (#{Cape::DSLDeprecated.name})" do |task_expression_in_use,
                                                                              options_in_use|
      specify 'by collecting Rake#each_task' do
        expect(rake).to receive(:each_task).with(task_expression_in_use)
        do_mirror_rake_tasks
      end

      specify 'by verifying that Capistrano is in use' do
        expect(dsl).to receive(:raise_unless_capistrano)
        do_mirror_rake_tasks
      end

      describe 'by sending Capistrano#define_rake_wrapper for Rake#each_task' do
        specify 'with the expected task' do
          expect(capistrano).to receive(:define_rake_wrapper).
                                with { |task, named_arguments| task == {:name => task_expression} }
          do_mirror_rake_tasks
        end

        specify 'with the expected named options' do
          expect(capistrano).to receive(:define_rake_wrapper).
                                with { |task, named_arguments| named_arguments.keys.sort == ([:binding] + options_in_use.keys).sort }
          do_mirror_rake_tasks
        end

        specify 'with a :binding option' do
          expect(capistrano).to receive(:define_rake_wrapper).
                                with { |task, named_arguments| named_arguments[:binding].is_a? Binding }
          do_mirror_rake_tasks
        end

        specify 'with any provided extra options' do
          expect(capistrano).to receive(:define_rake_wrapper).
                                with { |task, named_arguments| named_arguments.slice(*options_in_use.keys) == options_in_use }
          do_mirror_rake_tasks
        end
      end

      specify 'by returning itself' do
        expect(do_mirror_rake_tasks).to eq(dsl)
      end
    end

    describe 'with one scalar argument, an options hash, and a block --' do
      def do_mirror_rake_tasks
        super 'task:expression', :bar => :baz do |env|
          env['AN_ENV_VAR'] = 'an environment variable'
        end
      end

      behaves_like "a successful call (#{Cape::DSLDeprecated.name})",
                   'task:expression',
                   :bar => :baz

      it 'prints the expected deprecation messages to stderr' do
        do_mirror_rake_tasks
        expect(dsl.deprecation.stream.string).to eq(deprecation_preamble                                                  +
                                                        Cape::XTerm.bold('`'                                                  +
                                                                          'mirror_rake_tasks "task:expression", '             +
                                                                                            ':bar => :baz'                    +
                                                                         '`. '                                                +
                                                                         'Use this instead: '                                 +
                                                                         '`'                                                  +
                                                                          'mirror_rake_tasks("task:expression") { |recipes| ' +
                                                                            'recipes.options[:bar] = :baz '                   +
                                                                          '}'                                                 +
                                                                         '`')                                                 +
                                                        "\n")
      end
    end

    describe 'with one scalar argument and an options hash --' do
      def do_mirror_rake_tasks
        super 'task:expression', :bar => :baz
      end

      behaves_like "a successful call (#{Cape::DSLDeprecated.name})",
                   'task:expression',
                   :bar => :baz

      it 'prints the expected deprecation messages to stderr' do
        do_mirror_rake_tasks
        expect(dsl.deprecation.stream.string).to eq(deprecation_preamble                                                  +
                                                        Cape::XTerm.bold('`'                                                  +
                                                                          'mirror_rake_tasks "task:expression", '             +
                                                                                            ':bar => :baz'                    +
                                                                         '`. '                                                +
                                                                         'Use this instead: '                                 +
                                                                         '`'                                                  +
                                                                          'mirror_rake_tasks("task:expression") { |recipes| ' +
                                                                            'recipes.options[:bar] = :baz '                   +
                                                                          '}'                                                 +
                                                                         '`')                                                 +
                                                        "\n")
      end
    end

    describe 'with an options hash and a block --' do
      def do_mirror_rake_tasks
        super :bar => :baz do |env|
          env['AN_ENV_VAR'] = 'an environment variable'
        end
      end

      behaves_like "a successful call (#{Cape::DSLDeprecated.name})",
                   nil,
                   :bar => :baz

      it 'prints the expected deprecation messages to stderr' do
        do_mirror_rake_tasks
        expect(dsl.deprecation.stream.string).to eq(deprecation_preamble                                +
                                                        Cape::XTerm.bold('`'                                +
                                                                          'mirror_rake_tasks :bar => :baz'  +
                                                                         '`. '                              +
                                                                         'Use this instead: '               +
                                                                         '`'                                +
                                                                          'mirror_rake_tasks { |recipes| '  +
                                                                            'recipes.options[:bar] = :baz ' +
                                                                          '}'                               +
                                                                         '`')                               +
                                                        "\n")
      end
    end

    describe 'with an options hash --' do
      def do_mirror_rake_tasks
        super :bar => :baz
      end

      behaves_like "a successful call (#{Cape::DSLDeprecated.name})",
                   nil,
                   :bar => :baz

      it 'prints the expected deprecation messages to stderr' do
        do_mirror_rake_tasks
        expect(dsl.deprecation.stream.string).to eq(deprecation_preamble                                +
                                                        Cape::XTerm.bold('`'                                +
                                                                          'mirror_rake_tasks :bar => :baz'  +
                                                                         '`. '                              +
                                                                         'Use this instead: '               +
                                                                         '`'                                +
                                                                          'mirror_rake_tasks { |recipes| '  +
                                                                            'recipes.options[:bar] = :baz ' +
                                                                          '}'                               +
                                                                         '`')                               +
                                                        "\n")
      end
    end

    describe 'with one scalar argument and a block --' do
      def do_mirror_rake_tasks
        super 'task:expression' do |env|
          env['AN_ENV_VAR'] = 'an environment variable'
        end
      end

      behaves_like("a successful call (#{Cape::DSLDeprecated.name})",
                   'task:expression',
                   {})

      it 'prints no deprecation messages to stderr' do
        do_mirror_rake_tasks
        expect(dsl.deprecation.stream.string).to be_empty
      end
    end

    describe 'with one scalar argument --' do
      def do_mirror_rake_tasks
        super 'task:expression'
      end

      behaves_like("a successful call (#{Cape::DSLDeprecated.name})",
                   'task:expression',
                   {})

      it 'prints no deprecation messages to stderr' do
        do_mirror_rake_tasks
        expect(dsl.deprecation.stream.string).to be_empty
      end
    end

    describe 'without arguments --' do
      def do_mirror_rake_tasks
        super
      end

      behaves_like("a successful call (#{Cape::DSLDeprecated.name})",
                   nil,
                   {})

      it 'prints no deprecation messages to stderr' do
        do_mirror_rake_tasks
        expect(dsl.deprecation.stream.string).to be_empty
      end
    end
  end

  describe '#local_rake_executable' do
    before :each do
      allow(rake).to receive(:local_executable).and_return('foo')
    end

    it 'delegates to Rake#local_executable' do
      expect(rake).to receive(:local_executable)
      dsl.local_rake_executable
    end

    it 'returns the result of Rake#local_executable' do
      expect(dsl.local_rake_executable).to eq('foo')
    end
  end

  describe '#remote_rake_executable' do
    before :each do
      allow(rake).to receive(:remote_executable).and_return('foo')
    end

    it 'delegates to Rake#remote_executable' do
      expect(rake).to receive(:remote_executable)
      dsl.remote_rake_executable
    end

    it 'returns the result of Rake#remote_executable' do
      expect(dsl.remote_rake_executable).to eq('foo')
    end
  end
end