hammer_cli_foreman_virt_who_configure 0.0.1

data/test/functional/config/config_deploy_test.rb

@@ -0,0 +1,56 @@
+require_relative '../test_helper'
+
+describe "virt-who-config" do
+  describe "deploy" do
+    class FakeSystemCaller
+      def initialize(output, result=true)
+        @output = output
+        @result = result
+      end
+
+      def system(script)
+        puts @output
+        @result
+      end
+    end
+
+    before do
+      @cmd = ["virt-who-config", "deploy"]
+      @params = ['--name=test']
+      @script = 'echo BASH SCRIPT'
+    end
+
+    it "sends the script to #system" do
+      api_expects_search(:configs, :name => 'test').returns(index_response([config]))
+      api_expects(:configs, :deploy_script, 'Get config script').returns({'virt_who_config_script' => @script})
+
+      system_caller = mock
+      system_caller.expects(:system).with(@script).returns(true)
+
+      result = run_cmd(@cmd + @params, { :system_caller => system_caller })
+      assert_cmd(CommandExpectation.new, result)
+    end
+
+    it "prints output of the script to stdout" do
+      api_expects_search(:configs, :name => 'test').returns(index_response([config]))
+      api_expects(:configs, :deploy_script, 'Get config script').returns({'virt_who_config_script' => @script})
+
+      system_caller = FakeSystemCaller.new('Script output...')
+      expected_result = CommandExpectation.new('Script output...' + "\n")
+
+      result = run_cmd(@cmd + @params, { :system_caller => system_caller })
+      assert_cmd(expected_result, result)
+    end
+
+    it "returns HammerCLI::EX_SOFTWARE on config failure" do
+      api_expects_search(:configs, :name => 'test').returns(index_response([config]))
+      api_expects(:configs, :deploy_script, 'Get config script').returns({'virt_who_config_script' => @script})
+
+      system_caller = FakeSystemCaller.new('Script output...', false)
+      expected_result = CommandExpectation.new('Script output...' + "\n", '', HammerCLI::EX_SOFTWARE)
+
+      result = run_cmd(@cmd + @params, { :system_caller => system_caller })
+      assert_cmd(expected_result, result)
+    end
+  end
+end

data/test/functional/config/config_fetch_test.rb

@@ -0,0 +1,60 @@
+require_relative '../test_helper'
+
+describe "virt-who-config" do
+  describe "fetch" do
+    before do
+      @cmd = ["virt-who-config", "fetch"]
+      @script = 'echo BASH SCRIPT'
+    end
+
+    it "prints script to stdout by default" do
+      params = ['--name=test']
+
+      api_expects_search(:configs, :name => 'test').returns(index_response([config]))
+      api_expects(:configs, :deploy_script, 'Get config script').returns({'virt_who_config_script' => @script})
+
+      expected_result = CommandExpectation.new(@script + "\n")
+
+      result = run_cmd(@cmd + params)
+      assert_cmd(expected_result, result)
+    end
+
+    it "stores script into a file" do
+      file = Tempfile.new
+      file_path = file.path
+      file.unlink
+      begin
+        params = ['--name=test', '--output', file_path]
+
+        api_expects_search(:configs, :name => 'test').returns(index_response([config]))
+        api_expects(:configs, :deploy_script, 'Get config script').returns({'virt_who_config_script' => @script})
+
+        result = run_cmd(@cmd + params)
+
+        assert_cmd(CommandExpectation.new, result)
+        assert_equal(@script, File.read(file_path))
+      ensure
+        File.unlink(file_path)
+      end
+    end
+
+    it "refuses to store the script into an existing file" do
+      file = Tempfile.new
+      begin
+        params = ['--name=test', '--output', file.path]
+
+        api_expects_search(:configs, :name => 'test').returns(index_response([config]))
+        api_expects(:configs, :deploy_script, 'Get config script').returns({'virt_who_config_script' => @script})
+
+        result = run_cmd(@cmd + params)
+
+        expected_result = CommandExpectation.new('', /File at .* already exists, please specify a different path/, HammerCLI::EX_USAGE)
+
+        assert_cmd(expected_result, result)
+        assert_equal('', file.read)
+      ensure
+         file.unlink
+      end
+    end
+  end
+end

data/test/functional/config/config_info_test.rb

@@ -0,0 +1,147 @@
+require_relative '../test_helper'
+
+def expect_config_search(config)
+  api_expects_search(:configs, :name => config['name']).returns(index_response([config]))
+  api_expects(:configs, :show).with_params('id' => config['id']).returns(config)
+end
+
+def test_output_field(cmd, config_modification, output_label, output_value)
+  expect_config_search(config(config_modification))
+
+  output = FieldMatcher.new(output_label, output_value)
+
+  result = run_cmd(cmd)
+  assert_cmd(success_result(output), result)
+end
+
+def test_status_field(cmd, api_value, output_value)
+  test_output_field(cmd, { "status" => api_value }, 'Status', output_value)
+end
+
+def test_interval_field(cmd, api_value, output_value)
+  test_output_field(cmd, { "interval" => api_value }, 'Interval', output_value)
+end
+
+def test_filter_field(cmd, api_value, output_value)
+  test_output_field(cmd, { "filtering_mode" => api_value }, 'Filtering', output_value)
+end
+
+describe "virt-who-config" do
+  describe "info" do
+    before do
+      @cmd = ["virt-who-config", "info", '--name=test']
+    end
+
+    describe "interval formatting" do
+      it "formats 1 hour" do
+        test_interval_field(@cmd, 60, 'every hour')
+      end
+
+      it "formats 2 hours" do
+        test_interval_field(@cmd, 120, 'every 2 hours')
+      end
+    end
+
+    describe "status formatting" do
+      it "formats status unknown" do
+        test_status_field(@cmd, 'unknown', 'No Report Yet')
+      end
+
+      it "formats status ok" do
+        test_status_field(@cmd, 'ok', 'OK')
+      end
+
+      it "formats status out_of_date" do
+        test_status_field(@cmd, 'out_of_date', 'OK')
+      end
+
+      it "formats status error" do
+        test_status_field(@cmd, 'error', 'Error')
+      end
+
+      it "formats unknown status" do
+        test_status_field(@cmd, nil, 'Unknown configuration status')
+      end
+    end
+
+    describe "when filter is none" do
+      it "formats filter" do
+        test_filter_field(@cmd, 0, 'Unlimited')
+      end
+      it "hides whitelist field" do
+        expect_config_search(config("filtering_mode" => 0))
+        refute_match('Filtered hosts:', run_cmd(@cmd).out)
+      end
+
+      it "hides blacklist field" do
+        expect_config_search(config("filtering_mode" => 0))
+        refute_match('Excluded hosts:', run_cmd(@cmd).out)
+      end
+    end
+
+    describe "when filter is whitelist" do
+      it "formats filter" do
+        test_filter_field(@cmd, 1, 'Whitelist')
+      end
+
+      it "shows whitelist field" do
+        expect_config_search(config("filtering_mode" => 1, 'whitelist' => 'host1,hostb'))
+
+        output = FieldMatcher.new('Filtered hosts', 'host1,hostb')
+
+        result = run_cmd(@cmd)
+        assert_cmd(success_result(output), result)
+      end
+
+      it "shows empty whitelist field" do
+        expect_config_search(config("filtering_mode" => 1, 'whitelist' => nil))
+        assert_match('Filtered hosts:', run_cmd(@cmd).out)
+      end
+
+      it "hides blacklist field" do
+        expect_config_search(config("filtering_mode" => 1))
+        refute_match('Excluded hosts:', run_cmd(@cmd).out)
+      end
+    end
+
+    describe "when filter is blacklist" do
+      it "formats filter" do
+        test_filter_field(@cmd, 2, 'Blacklist')
+      end
+
+      it "shows blacklist field" do
+        expect_config_search(config("filtering_mode" => 2, 'blacklist' => 'host1,hostb'))
+
+        output = FieldMatcher.new('Excluded hosts', 'host1,hostb')
+
+        result = run_cmd(@cmd)
+        assert_cmd(success_result(output), result)
+      end
+
+      it "shows empty blacklist field" do
+        expect_config_search(config("filtering_mode" => 2, 'whitelist' => nil))
+        assert_match('Excluded hosts:', run_cmd(@cmd).out)
+      end
+
+      it "hides whitelist field" do
+        expect_config_search(config("filtering_mode" => 2))
+        refute_match('Filtered hosts:', run_cmd(@cmd).out)
+      end
+    end
+
+    describe "when filter is unknown value" do
+      it "formats filter" do
+        test_filter_field(@cmd, nil, 'Unknown listing mode')
+      end
+      it "hides whitelist field" do
+        expect_config_search(config("filtering_mode" => 0))
+        refute_match('Filtered hosts:', run_cmd(@cmd).out)
+      end
+
+      it "hides blacklist field" do
+        expect_config_search(config("filtering_mode" => 0))
+        refute_match('Excluded hosts:', run_cmd(@cmd).out)
+      end
+    end
+  end
+end

data/test/functional/config/config_list_test.rb

@@ -0,0 +1,53 @@
+require_relative '../test_helper'
+
+describe "virt-who-config" do
+  describe "list" do
+    before do
+      @cmd = ["virt-who-config", "list"]
+    end
+
+    it "formats interval and status" do
+      configs = [
+        config,
+        config('status' => 'ok', 'interval' => 120),
+        config('status' => 'out_of_date', 'interval' => 240),
+        config('status' => 'error', 'interval' => 480),
+      ]
+
+      api_expects(:configs, :index).returns(index_response(configs))
+
+      output = IndexMatcher.new([
+        ['ID', 'NAME', 'INTERVAL',      'STATUS',        'LAST REPORT AT'],
+        ['11', 'test', 'every hour',    'No Report Yet', ''],
+        ['11', 'test', 'every 2 hours', 'OK',            ''],
+        ['11', 'test', 'every 4 hours', 'OK',            ''],
+        ['11', 'test', 'every 8 hours', 'Error',         '']
+      ])
+
+      result = run_cmd(@cmd)
+      assert_cmd(success_result(output), result)
+    end
+
+    it "supports pagination" do
+      params = ['--page=2', '--per-page=10', '--order', 'name ASC']
+
+      api_expects(:configs, :index).with_params(
+        'page' => '2',
+        'per_page' => '10',
+        'order' => 'name ASC',
+      ).returns(index_response([]))
+
+      result = run_cmd(@cmd + params)
+      assert_cmd(success_result(/.*/), result)
+    end
+
+    it "supports search" do
+      params = ['--search', 'name ~ test']
+
+      api_expects(:configs, :index).with_params('search' => 'name ~ test').returns(index_response([]))
+
+      result = run_cmd(@cmd + params)
+      assert_cmd(success_result(/.*/), result)
+    end
+  end
+end

data/test/functional/config/config_update_test.rb

@@ -0,0 +1,46 @@
+require_relative '../test_helper'
+
+describe "virt-who-config" do
+  describe "update" do
+    before do
+      @cmd = ["virt-who-config", "update"]
+      @update_args = {
+        :name => 'test',
+        :new_name => 'test2',
+        :interval => 60,
+        :filtering_mode => 'blacklist',
+        :hypervisor_id => 'uuid',
+        :hypervisor_type => 'libvirt',
+        :hypervisor_server => 1,
+        :hypervisor_username => 1,
+        :satellite_url => 1,
+        :organization_id => 1
+      }
+    end
+
+    it "sends values to api" do
+      params = hash_to_opts(@update_args)
+
+      expected_result = success_result("Virt Who configuration [test] updated\n")
+
+      api_expects_search(:configs, :name => 'test').returns(index_response([config]))
+      api_expects(:configs, :update, 'Create configuration').with_params(
+        'id' => 11,
+        'foreman_virt_who_configure_config' => {
+          'name' => 'test2',
+          'interval' => '60',
+          'filtering_mode' => 2,
+          'hypervisor_id' => 'uuid',
+          'hypervisor_type' => 'libvirt',
+          'hypervisor_server' => '1',
+          'hypervisor_username' => '1',
+          'satellite_url' => '1',
+          'organization_id' => 1
+        }
+      ).returns({:config => config})
+
+      result = run_cmd(@cmd + params)
+      assert_cmd(expected_result, result)
+    end
+  end
+end

data/test/functional/test_helper.rb

@@ -0,0 +1,60 @@
+require_relative '../test_helper'
+
+require 'hammer_cli/testing/command_assertions'
+require 'hammer_cli/testing/output_matchers'
+
+include HammerCLI::Testing::CommandAssertions
+include HammerCLI::Testing::OutputMatchers
+
+def missing_arguments_result(argument_name)
+  HammerCLI::Testing::CommandAssertions::CommandExpectation.new('', /Missing arguments for.*\[#{argument_name}\]/, HammerCLI::EX_USAGE)
+end
+
+def assert_requires_argument(cmd, params, required_argument_name)
+  expected_result = missing_arguments_result(required_argument_name)
+
+  api_expects_no_call
+  result = run_cmd(cmd + params)
+  assert_cmd(expected_result, result)
+end
+
+def assert_usage_error(cmd, params, error_msg)
+  expected_result = usage_error_result(cmd,
+    error_msg,
+    "Could not create the Virt Who configuration")
+
+  api_expects_no_call
+  result = run_cmd(cmd + params)
+  assert_cmd(expected_result, result)
+end
+
+def hash_to_opts(hash, options={})
+  hash.reject do |k|
+    k == options[:reject]
+  end.map do |key, value|
+    "--#{key.to_s.gsub('_', '-')}=#{value}"
+  end
+end
+
+def config(attrs = {})
+  {
+    "name" => "test",
+    "interval" => 60,
+    "organization_id" => 1,
+    "whitelist" => "",
+    "blacklist" => "",
+    "hypervisor_id" => "hostname",
+    "hypervisor_type" => "libvirt",
+    "hypervisor_server" => "libvirt.test.org",
+    "hypervisor_username" => "user",
+    "debug" => false,
+    "satellite_url" => "10.34.131.166",
+    "proxy" => "",
+    "no_proxy" => "",
+    "status" => "unknown",
+    "last_report_at" => nil,
+    "out_of_date_at" => nil,
+    "filtering_mode" => 0,
+    "id" => 11
+  }.merge(attrs)
+end

data/test/test_helper.rb

@@ -0,0 +1,15 @@
+require 'minitest/autorun'
+require 'minitest/spec'
+require "mocha/setup"
+
+require 'hammer_cli'
+require 'hammer_cli_foreman/testing/api_expectations'
+
+FOREMAN_VERSION = Gem::Version.new(ENV['TEST_API_VERSION'] || '1.15')
+
+include HammerCLIForeman::Testing::APIExpectations
+HammerCLI.context[:api_connection].create('foreman') do
+  api_connection({}, FOREMAN_VERSION)
+end
+
+require 'hammer_cli_foreman_virt_who_configure'

data/test/unit/system_caller_test.rb

@@ -0,0 +1,26 @@
+require 'hammer_cli_foreman_virt_who_configure/system_caller'
+require_relative '../test_helper'
+
+describe "SystemCaller" do
+  class CaptureContentTempfile < Tempfile
+    attr_accessor :contents
+
+    def write(data)
+      @contents ||= []
+      @contents << data
+      super
+    end
+  end
+
+  let(:script) { 'echo "Test"' }
+
+  it 'uses tempfile for executing the script' do
+    tmp_file = CaptureContentTempfile.new
+    Kernel.expects(:system).with("/usr/bin/bash #{tmp_file.path}")
+
+    sys_caller = HammerCLIForemanVirtWhoConfigure::SystemCaller.new(tmp_file)
+    sys_caller.system(script)
+
+    assert_equal([script], tmp_file.contents)
+  end
+end