require 'spec_helper'

module Producer::Core
  describe CLI do
    include ExitHelpers
    include FixturesHelpers

    let(:recipe_file) { fixture_path_for 'recipes/some_recipe.rb' }
    let(:options)     { [] }
    let(:arguments)   { [*options, recipe_file] }
    let(:stdout)      { StringIO.new }

    subject(:cli)     { CLI.new(arguments, stdout: stdout) }

    describe '.run!' do
      let(:cli)       { double('cli').as_null_object }
      let(:output)    { StringIO.new }
      subject(:run)   { described_class.run! arguments, output: output }

      before { allow(described_class).to receive(:new) { cli } }

      it 'builds a new CLI with given arguments' do
        expect(described_class).to receive(:new).with(arguments)
        run
      end

      it 'runs the CLI' do
        expect(cli).to receive :run
        run
      end

      it 'parses CLI arguments' do
        expect(cli).to receive :parse_arguments!
        run
      end

      context 'when an argument error is raised' do
        before do
          allow(cli).to receive(:parse_arguments!)
            .and_raise described_class::ArgumentError
        end

        it 'exits with a return status of 64' do
          expect { run }.to raise_error(SystemExit) do |e|
            expect(e.status).to eq 64
          end
        end

        it 'prints the usage' do
          trap_exit { run }
          expect(output.string).to match /\AUsage: .+/
        end
      end

      context 'when a runtime error is raised' do
        before do
          allow(cli).to receive(:run)
            .and_raise RuntimeError, 'some message'
        end

        it 'exits with a return status of 70' do
          expect { run }.to raise_error(SystemExit) do |e|
            expect(e.status).to eq 70
          end
        end

        it 'prints exception name and message' do
          trap_exit { run }
          expect(output.string).to match /\ARuntimeError: some message/
        end
      end
    end

    describe '#initialize' do
      it 'assigns the env with CLI output' do
        expect(cli.env.output).to be stdout
      end

      context 'without options' do
        subject(:cli) { described_class.new(arguments) }

        it 'assigns $stdout as the default standard output' do
          expect(cli.stdout).to be $stdout
        end
      end
    end

    describe '#arguments' do
      it 'returns the assigned arguments' do
        expect(cli.arguments).to eq arguments
      end
    end

    describe '#stdout' do
      it 'returns the assigned standard output' do
        expect(cli.stdout).to be stdout
      end
    end

    describe '#env' do
      it 'returns the assigned env' do
        expect(cli.env).to be_an Env
      end
    end

    describe '#parse_arguments!' do
      context 'with options' do
        let(:options) { %w[-v] }

        before { cli.parse_arguments! }

        it 'removes options from arguments' do
          expect(cli.arguments).to eq [recipe_file]
        end

        context 'verbose' do
          it 'enables env verbose mode' do
            expect(cli.env).to be_verbose
          end
        end

        context 'dry run' do
          let(:options) { %w[-n] }

          it 'enables env dry run mode' do
            expect(cli.env).to be_dry_run
          end
        end
      end

      context 'without arguments' do
        let(:arguments) { [] }

        it 'raises the argument error exception' do
          expect { cli.parse_arguments! }.to raise_error described_class::ArgumentError
        end
      end
    end

    describe '#run' do
      it 'process recipe tasks with given worker' do
        worker = double 'worker'
        allow(cli).to receive(:worker) { worker }
        expect(worker).to receive(:process)
          .with([an_instance_of(Task), an_instance_of(Task)])
        cli.run
      end
    end

    describe '#load_recipe' do
      it 'evaluates the recipe file with the CLI env' do
        expect(Recipe)
          .to receive(:evaluate_from_file).with(recipe_file, cli.env)
        cli.load_recipe
      end

      it 'returns the recipe' do
        expect(cli.load_recipe).to be_a Recipe
      end
    end

    describe '#worker' do
      it 'returns a worker' do
        expect(cli.worker).to be_a Worker
      end

      it 'assigns the CLI env' do
        expect(cli.worker.env).to eq cli.env
      end
    end
  end
end