hammer_cli_foreman_virt_who_configure 0.0.9 → 0.1.1

data/test/functional/config/config_create_test.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require_relative '../test_helper'
 
-describe "virt-who-config" do
-  describe "create" do
+describe 'virt-who-config' do
+  describe 'create' do
     before do
-      @cmd = ["virt-who-config", "create"]
+      @cmd = ['virt-who-config', 'create']
       @required_args = {
         :name => 'test',
         :interval => 60,
@@ -17,57 +19,47 @@ describe "virt-who-config" do
       }
     end
 
-    it "requires --name" do
+    it 'requires --name' do
       params = hash_to_opts(@required_args, :reject => :name)
       assert_requires_argument(@cmd, params, 'name')
     end
 
-    it "requires --interval" do
+    it 'requires --interval' do
       params = hash_to_opts(@required_args, :reject => :interval)
       assert_requires_argument(@cmd, params, 'interval')
     end
 
-    it "requires --filtering-mode" do
+    it 'requires --filtering-mode' do
       params = hash_to_opts(@required_args, :reject => :filtering_mode)
-      assert_requires_argument(@cmd, params, 'filtering_mode')
+      assert_requires_argument(@cmd, params, 'filtering-mode')
     end
 
-    it "requires --hypervisor-id" do
+    it 'requires --hypervisor-id' do
       params = hash_to_opts(@required_args, :reject => :hypervisor_id)
-      assert_requires_argument(@cmd, params, 'hypervisor_id')
+      assert_requires_argument(@cmd, params, 'hypervisor-id')
     end
 
-    it "validates --hypervisor-id values" do
+    it 'validates --hypervisor-id values' do
       params = hash_to_opts(@required_args.merge(:hypervisor_id => 'other'))
-      assert_usage_error(@cmd, params, "option '--hypervisor-id': value must be one of 'hostname', 'uuid', 'hwuuid'")
+      assert_usage_error(@cmd, params, "Option '--hypervisor-id': Value must be one of 'hostname', 'uuid', 'hwuuid'..")
     end
 
-    it "requires --hypervisor-type" do
+    it 'requires --hypervisor-type' do
       params = hash_to_opts(@required_args, :reject => :hypervisor_type)
-      assert_requires_argument(@cmd, params, 'hypervisor_type')
+      assert_requires_argument(@cmd, params, 'hypervisor-type')
     end
 
-    it "validates --hypervisor-type values" do
+    it 'validates --hypervisor-type values' do
       params = hash_to_opts(@required_args.merge(:hypervisor_type => 'other'))
-      assert_usage_error(@cmd, params, "option '--hypervisor-type': value must be one of 'esx', 'rhevm', 'hyperv', 'xen', 'libvirt'")
-    end
-
-    it "requires --hypervisor-server" do
-      params = hash_to_opts(@required_args, :reject => :hypervisor_server)
-      assert_requires_argument(@cmd, params, 'hypervisor_server')
-    end
-
-    it "requires --hypervisor-username" do
-      params = hash_to_opts(@required_args, :reject => :hypervisor_username)
-      assert_requires_argument(@cmd, params, 'hypervisor_username')
+      assert_usage_error(@cmd, params, "Option '--hypervisor-type': Value must be one of 'esx', 'hyperv', 'libvirt', 'kubevirt', 'ahv'..")
     end
 
-    it "requires --satellite-url" do
+    it 'requires --satellite-url' do
       params = hash_to_opts(@required_args, :reject => :satellite_url)
-      assert_requires_argument(@cmd, params, 'satellite_url')
+      assert_requires_argument(@cmd, params, 'satellite-url')
     end
 
-    it "sends values to api" do
+    it 'sends values to api' do
       params = hash_to_opts(@required_args)
 
       expected_result = success_result("Virt Who configuration [test] created\n")
@@ -84,7 +76,7 @@ describe "virt-who-config" do
           'satellite_url' => '1',
           'organization_id' => 1
         }
-      ).returns({:config => { :name => 'test'}})
+      ).returns(:config => { :name => 'test'})
 
       result = run_cmd(@cmd + params)
       assert_cmd(expected_result, result)

data/test/functional/config/config_deploy_test.rb

@@ -1,55 +1,57 @@
+# frozen_string_literal: true
+
 require_relative '../test_helper'
 
-describe "virt-who-config" do
-  describe "deploy" do
+describe 'virt-who-config' do
+  describe 'deploy' do
     class FakeSystemCaller
-      def initialize(output, result=true)
+      def initialize(output, result = true)
         @output = output
         @result = result
       end
 
-      def system(script)
+      def system(_script)
         puts @output
         @result
       end
     end
 
     before do
-      @cmd = ["virt-who-config", "deploy"]
+      @cmd = ['virt-who-config', 'deploy']
       @params = ['--name=test']
       @script = 'echo BASH SCRIPT'
     end
 
-    it "sends the script to #system" do
+    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})
+      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 })
+      result = run_cmd(@cmd + @params, :system_caller => system_caller)
       assert_cmd(CommandExpectation.new, result)
     end
 
-    it "prints output of the script to stdout" do
+    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})
+      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 })
+      result = run_cmd(@cmd + @params, :system_caller => system_caller)
       assert_cmd(expected_result, result)
     end
 
-    it "returns HammerCLI::EX_SOFTWARE on config failure" do
+    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})
+      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 })
+      result = run_cmd(@cmd + @params, :system_caller => system_caller)
       assert_cmd(expected_result, result)
     end
   end

data/test/functional/config/config_fetch_test.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 require_relative '../test_helper'
 
-describe "virt-who-config" do
-  describe "fetch" do
+describe 'virt-who-config' do
+  describe 'fetch' do
     before do
-      @cmd = ["virt-who-config", "fetch"]
+      @cmd = ['virt-who-config', 'fetch']
       @script = 'echo BASH SCRIPT'
     end
 
-    it "prints script to stdout by default" do
+    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})
+      api_expects(:configs, :deploy_script, 'Get config script').returns('virt_who_config_script' => @script)
 
       expected_result = CommandExpectation.new(@script + "\n")
 
@@ -19,7 +21,7 @@ describe "virt-who-config" do
       assert_cmd(expected_result, result)
     end
 
-    it "stores script into a file" do
+    it 'stores script into a file' do
       file = Tempfile.new
       file_path = file.path
       file.unlink
@@ -27,7 +29,7 @@ describe "virt-who-config" do
         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})
+        api_expects(:configs, :deploy_script, 'Get config script').returns('virt_who_config_script' => @script)
 
         result = run_cmd(@cmd + params)
 
@@ -38,13 +40,13 @@ describe "virt-who-config" do
       end
     end
 
-    it "refuses to store the script into an existing file" do
+    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})
+        api_expects(:configs, :deploy_script, 'Get config script').returns('virt_who_config_script' => @script)
 
         result = run_cmd(@cmd + params)
 
@@ -53,7 +55,7 @@ describe "virt-who-config" do
         assert_cmd(expected_result, result)
         assert_equal('', file.read)
       ensure
-         file.unlink
+        file.unlink
       end
     end
   end

data/test/functional/config/config_info_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../test_helper'
 
 def expect_config_search(config)
@@ -15,77 +17,77 @@ def test_output_field(cmd, config_modification, output_label, output_value)
 end
 
 def test_status_field(cmd, api_value, output_value)
-  test_output_field(cmd, { "status" => api_value }, 'Status', 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)
+  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)
+  test_output_field(cmd, { 'filtering_mode' => api_value }, 'Filtering', output_value)
 end
 
-describe "virt-who-config" do
-  describe "info" do
+describe 'virt-who-config' do
+  describe 'info' do
     before do
-      @cmd = ["virt-who-config", "info", '--name=test']
+      @cmd = ['virt-who-config', 'info', '--name=test']
     end
 
-    describe "interval formatting" do
-      it "formats 1 hour" do
+    describe 'interval formatting' do
+      it 'formats 1 hour' do
         test_interval_field(@cmd, 60, 'every hour')
       end
 
-      it "formats 2 hours" do
+      it 'formats 2 hours' do
         test_interval_field(@cmd, 120, 'every 2 hours')
       end
     end
 
-    describe "status formatting" do
-      it "formats status unknown" do
+    describe 'status formatting' do
+      it 'formats status unknown' do
         test_status_field(@cmd, 'unknown', 'No Report Yet')
       end
 
-      it "formats status ok" do
+      it 'formats status ok' do
         test_status_field(@cmd, 'ok', 'OK')
       end
 
-      it "formats status out_of_date" do
+      it 'formats status out_of_date' do
         test_status_field(@cmd, 'out_of_date', 'OK')
       end
 
-      it "formats status error" do
+      it 'formats status error' do
         test_status_field(@cmd, 'error', 'Error')
       end
 
-      it "formats unknown status" do
+      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
+    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))
+      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))
+      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
+    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'))
+      it 'shows whitelist field' do
+        expect_config_search(config('filtering_mode' => 1, 'whitelist' => 'host1,hostb'))
 
         output = FieldMatcher.new('Filtered hosts', 'host1,hostb')
 
@@ -93,24 +95,24 @@ describe "virt-who-config" do
         assert_cmd(success_result(output), result)
       end
 
-      it "shows empty whitelist field" do
-        expect_config_search(config("filtering_mode" => 1, 'whitelist' => nil))
+      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))
+      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
+    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'))
+      it 'shows blacklist field' do
+        expect_config_search(config('filtering_mode' => 2, 'blacklist' => 'host1,hostb'))
 
         output = FieldMatcher.new('Excluded hosts', 'host1,hostb')
 
@@ -118,28 +120,28 @@ describe "virt-who-config" do
         assert_cmd(success_result(output), result)
       end
 
-      it "shows empty blacklist field" do
-        expect_config_search(config("filtering_mode" => 2, 'whitelist' => nil))
+      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))
+      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
+    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))
+      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))
+      it 'hides blacklist field' do
+        expect_config_search(config('filtering_mode' => 0))
         refute_match('Excluded hosts:', run_cmd(@cmd).out)
       end
     end

data/test/functional/config/config_list_test.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 require_relative '../test_helper'
 
-describe "virt-who-config" do
-  describe "list" do
+describe 'virt-who-config' do
+  describe 'list' do
     before do
-      @cmd = ["virt-who-config", "list"]
+      @cmd = ['virt-who-config', 'list']
     end
 
-    it "formats interval and status" do
+    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),
+        config('status' => 'error', 'interval' => 480)
       ]
 
       api_expects(:configs, :index).returns(index_response(configs))
@@ -28,20 +30,20 @@ describe "virt-who-config" do
       assert_cmd(success_result(output), result)
     end
 
-    it "supports pagination" do
+    it 'supports pagination' do
       params = ['--page=2', '--per-page=10', '--order', 'name ASC']
 
       api_expects(:configs, :index).with_params(
-        'page' => '2',
+        'page' => 2,
         'per_page' => '10',
-        'order' => 'name ASC',
+        'order' => 'name ASC'
       ).returns(index_response([]))
 
       result = run_cmd(@cmd + params)
       assert_cmd(success_result(/.*/), result)
     end
 
-    it "supports search" do
+    it 'supports search' do
       params = ['--search', 'name ~ test']
 
       api_expects(:configs, :index).with_params('search' => 'name ~ test').returns(index_response([]))

data/test/functional/config/config_update_test.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require_relative '../test_helper'
 
-describe "virt-who-config" do
-  describe "update" do
+describe 'virt-who-config' do
+  describe 'update' do
     before do
-      @cmd = ["virt-who-config", "update"]
+      @cmd = ['virt-who-config', 'update']
       @update_args = {
         :name => 'test',
         :new_name => 'test2',
@@ -18,7 +20,7 @@ describe "virt-who-config" do
       }
     end
 
-    it "sends values to api" do
+    it 'sends values to api' do
       params = hash_to_opts(@update_args)
 
       expected_result = success_result("Virt Who configuration [test] updated\n")
@@ -37,7 +39,7 @@ describe "virt-who-config" do
           'satellite_url' => '1',
           'organization_id' => 1
         }
-      ).returns({:config => config})
+      ).returns(:config => config)
 
       result = run_cmd(@cmd + params)
       assert_cmd(expected_result, result)

data/test/functional/test_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../test_helper'
 
 require 'hammer_cli/testing/command_assertions'
@@ -7,7 +9,7 @@ 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)
+  HammerCLI::Testing::CommandAssertions::CommandExpectation.new('', /Missing arguments for.*#{argument_name}/, HammerCLI::EX_USAGE)
 end
 
 def assert_requires_argument(cmd, params, required_argument_name)
@@ -21,14 +23,14 @@ end
 def assert_usage_error(cmd, params, error_msg)
   expected_result = usage_error_result(cmd,
     error_msg,
-    "Could not create the Virt Who configuration")
+    '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={})
+def hash_to_opts(hash, options = {})
   hash.reject do |k|
     k == options[:reject]
   end.map do |key, value|
@@ -38,23 +40,23 @@ 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
+    '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

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require 'minitest/autorun'
 require 'minitest/spec'
-require "mocha/setup"
+require 'mocha/minitest'
 
 require 'hammer_cli'
 require 'hammer_cli_foreman/testing/api_expectations'
 
-FOREMAN_VERSION = Gem::Version.new(ENV['TEST_API_VERSION'] || '1.15')
+FOREMAN_VERSION = Gem::Version.new(ENV['TEST_API_VERSION'] || '3.11')
 
 include HammerCLIForeman::Testing::APIExpectations
 HammerCLI.context[:api_connection].create('foreman') do

data/test/unit/system_caller_test.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'hammer_cli_foreman_virt_who_configure/system_caller'
 require_relative '../test_helper'
 
-describe "SystemCaller" do
+describe 'SystemCaller' do
   class CaptureContentTempfile < Tempfile
     attr_accessor :contents
 
@@ -16,7 +18,8 @@ describe "SystemCaller" do
 
   it 'uses tempfile for executing the script' do
     tmp_file = CaptureContentTempfile.new
-    Kernel.expects(:system).with("/usr/bin/bash #{tmp_file.path}")
+    vars = HammerCLIForemanVirtWhoConfigure::SystemCaller.new.clean_env_vars
+    Kernel.expects(:system).with(vars, "/usr/bin/bash #{tmp_file.path}", unsetenv_others: true)
 
     sys_caller = HammerCLIForemanVirtWhoConfigure::SystemCaller.new(tmp_file)
     sys_caller.system(script)