require_relative 'test_helper'

describe HammerCLI::Apipie::Command do

  class ParentCommand < HammerCLI::Apipie::Command
    action :show
  end

  class OptionCommand < HammerCLI::Apipie::Command
    resource :architectures, :create

    def option_name
      'test_name'
    end

    def option_operatingsystem_ids
      nil
    end
  end

  class CommandA < HammerCLI::Apipie::Command
    resource :architectures, :index

    class CommandB < ParentCommand
    end
  end

  class CommandC < CommandA
  end

  class CommandUnsupp < HammerCLI::Apipie::Command
    resource :architectures, :unsupptest
  end

  let(:ctx) { { :adapter => :silent, :interactive => false } }
  let(:cmd_class) { Class.new(HammerCLI::Apipie::Command) }
  let(:cmd) { cmd_class.new("", ctx) }
  let(:cmd_run) { cmd.run([]) }

  context "unsupported commands" do
    let(:cmd_class) { Class.new(CommandUnsupp) }
    let(:cmd) { cmd_class.new("unsupported", ctx) }
    it "should print help for unsupported command" do
      assert_match(/.*Unfortunately the server does not support such operation.*/, cmd.help)
    end

  end

  context "setting resources" do

    it "should set resource and action together" do
      cmd_class.resource :architectures, :index

      _(cmd.resource.name).must_equal :architectures
      _(cmd_class.resource.name).must_equal :architectures

      _(cmd.action).must_equal :index
      _(cmd_class.action).must_equal :index
    end

    it "should set resource alone" do
      cmd_class.resource :architectures

      _(cmd.resource.name).must_equal :architectures
      _(cmd_class.resource.name).must_equal :architectures

      assert_nil cmd.action
      assert_nil cmd_class.action
    end

    it "should set resource and action alone" do
      cmd_class.resource :architectures
      cmd_class.action :index

      _(cmd.resource.name).must_equal :architectures
      _(cmd_class.resource.name).must_equal :architectures

      _(cmd.action).must_equal :index
      _(cmd_class.action).must_equal :index
    end

    it "inherits action from a parent class" do
      cmd_b = CommandA::CommandB.new("", ctx)
      _(cmd_b.action).must_equal :show
      _(cmd_b.class.action).must_equal :show
    end

    it "looks up resource in the class' modules" do
      cmd_b = CommandA::CommandB.new("", ctx)
      _(cmd_b.resource.name).must_equal :architectures
      _(cmd_b.class.resource.name).must_equal :architectures
    end

    it "looks up resource in the superclass" do
      cmd_c = CommandC.new("", ctx)
      _(cmd_c.resource.name).must_equal :architectures
      _(cmd_c.class.resource.name).must_equal :architectures
    end
  end

  it "should raise exception when no action is defined" do
    cmd.stubs(:handle_exception).returns(HammerCLI::EX_SOFTWARE)
    _(cmd_run).must_equal HammerCLI::EX_SOFTWARE
  end

  context "resource defined" do
    it "should perform a call to api when resource is defined" do
      ApipieBindings::API.any_instance.expects(:call).returns([])
      cmd.class.resource :architectures, :index
      _(cmd_run).must_equal 0
    end
  end

  context "options" do

    it "should collect method options from given options" do
      cmd_opt = OptionCommand.new("", ctx)
      params = cmd_opt.class.resource.action(:create).params
      _(cmd_opt.method_options_for_params(params, {'option_name' => 'name'})).must_equal({"architecture" => {"name" => "name"}})
    end

    it "should collect method options from methods" do
      cmd_opt = OptionCommand.new("", ctx)
      params = cmd_opt.class.resource.action(:create).params
      _(cmd_opt.method_options_for_params(params, {})).must_equal({"architecture"=>{"name"=>"test_name"}})
    end

  end

  context 'verbosity' do
    class MessagesCommand < HammerCLI::Apipie::Command
      def execute
        messages = %w[quiet unix verbose very_verbose]
        print_message(messages[0], {}, verbosity: HammerCLI::V_QUIET)
        print_message(messages[1], {}, verbosity: HammerCLI::V_UNIX)
        print_message(messages[2], {}, verbosity: HammerCLI::V_VERBOSE)
        print_message(messages[3], {}, verbosity: HammerCLI::V_VERBOSE + 1)
        HammerCLI::EX_OK
      end
    end

    let(:messages) { %w[quiet unix verbose very_verbose] }

    it 'should print quiet messages only when hammer verbosity level is V_QUIET' do
      expected_messages = [
        messages[0],
        ''
      ].join("\n")
      expected_result = success_result(expected_messages)
      result = run_cmd([], { :verbosity => HammerCLI::V_QUIET }, Class.new(MessagesCommand))
      assert_cmd(expected_result, result)
    end

    it 'should print quiet + no-verbose messages only when hammer verbosity level is V_UNIX' do
      expected_messages = [
        messages[0],
        messages[1],
        ''
      ].join("\n")
      expected_result = success_result(expected_messages)
      result = run_cmd([], { :verbosity => HammerCLI::V_UNIX }, MessagesCommand)
      assert_cmd(expected_result, result)
    end

    it 'should print quiet + no-verbose + verbose messages only when hammer verbosity level is V_VERBOSE' do
      expected_messages = [
        messages[0],
        messages[1],
        messages[2],
        ''
      ].join("\n")
      expected_result = success_result(expected_messages)
      result = run_cmd([], { :verbosity => HammerCLI::V_VERBOSE }, MessagesCommand)
      assert_cmd(expected_result, result)
    end
  end
end