moose-inventory 1.0.9 → 2.1

data/spec/lib/moose_inventory/cli/group_rmhost_spec.rb

@@ -1,44 +1,28 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/BlockLength
 require 'spec_helper'
 
-# TODO: the usual respond_to? method doesn't seem to work on Thor objects.
 # Why not? For now, we'll check against instance_methods.
 
 RSpec.describe Moose::Inventory::Cli::Group do
   before(:all) do
-    # Set up the configuration object
-    @mockarg_parts = {
-      config:  File.join(spec_root, 'config/config.yml'),
-      format:  'yaml',
-      env:     'test',
-    }
-
-    @mockargs = []
-    @mockarg_parts.each do |key, val|
-      @mockargs << "--#{key}"
-      @mockargs << val
-    end
-
-    @console = Moose::Inventory::Cli::Formatter
-    @config = Moose::Inventory::Config
-    @config.init(@mockargs)
-
-    @db = Moose::Inventory::DB
-    @db.init if @db.db.nil?
-
-    @group = Moose::Inventory::Cli::Group
-    @host = Moose::Inventory::Cli::Host
-    @app = Moose::Inventory::Cli::Application
+    setup_cli_harness(
+      command_class: Moose::Inventory::Cli::Group,
+      command_ivar: :@group,
+      extra_commands: { :@host => Moose::Inventory::Cli::Host }
+    )
   end
 
   before(:each) do
-    @db.reset
+    reset_cli_harness
   end
 
   #====================
   describe 'rmgroup' do
     #----------------
     it 'should be responsive' do
-      result = @group.instance_methods(false).include?(:rmhost)
+      result = @group.method_defined?(:rmhost, false)
       expect(result).to eq(true)
     end
 
@@ -47,7 +31,7 @@ RSpec.describe Moose::Inventory::Cli::Group do
     #------------------------
     it '<missing args> ... should abort with an error' do
       actual = runner  do
-        @app.start(%w(group rmhost)) # <- no group or hosts given
+        @app.start(%w[group rmhost]) # <- no group or hosts given
       end
 
       # Check output
@@ -61,16 +45,16 @@ RSpec.describe Moose::Inventory::Cli::Group do
       group_name = 'not-a-group'
       host_name = 'example'
       actual = runner do
-        @app.start(%W(group rmhost #{group_name} #{host_name}))
+        @app.start(%W[group rmhost #{group_name} #{host_name} --yes])
       end
 
       # Check output
       desired = { aborted: true }
       desired[:STDOUT] =
-        "Dissociate group '#{group_name}' from host(s) '#{host_name}':\n"\
-        "  - retrieve group '#{group_name}'...\n"
+        "Dissociate group '#{group_name}' from host(s) '#{host_name}':\n  " \
+        "- retrieve group '#{group_name}'...\n"
       desired[:STDERR] =
-        "ERROR: The group '#{group_name}' does not exist.\n"\
+        "ERROR: The group '#{group_name}' does not exist.\n" \
         "An error occurred during a transaction, any changes have been rolled back.\n"
       expected(actual, desired)
     end
@@ -80,9 +64,9 @@ RSpec.describe Moose::Inventory::Cli::Group do
       host_name = 'test1'
       group_name = 'group1'
 
-      runner { @app.start(%W(host add #{host_name})) }
-      runner { @app.start(%W(group add #{group_name})) }
-      runner { @app.start(%W(group addhost #{group_name} #{host_name})) }
+      runner { @app.start(%W[host add #{host_name}]) }
+      runner { @app.start(%W[group add #{group_name}]) }
+      runner { @app.start(%W[group addhost #{group_name} #{host_name}]) }
 
       #
       # Dissociate the host
@@ -90,32 +74,48 @@ RSpec.describe Moose::Inventory::Cli::Group do
       # 2. expect that no association with ungrouped is made.
 
       actual = runner do
-        @app.start(%W(group rmhost #{group_name} #{host_name}))
+        @app.start(%W[group rmhost #{group_name} #{host_name} --yes])
       end
 
       # @console.dump(actual, 'y')
 
-      # rubocop:disable Metrics/LineLength
       desired = { aborted: false }
       desired[:STDOUT] =
-        "Dissociate group '#{group_name}' from host(s) '#{host_name}':\n"\
-        "  - retrieve group '#{group_name}'...\n"\
-        "    - OK\n"\
-        "  - remove association {group:#{group_name} <-> host:#{host_name}}...\n"\
-        "    - OK\n"\
-        "  - add automatic association {group:ungrouped <-> host:#{host_name}}...\n"\
-        "    - OK\n"\
-        "  - all OK\n"\
+        "Dissociate group '#{group_name}' from host(s) '#{host_name}':\n  " \
+        "- retrieve group '#{group_name}'...\n    " \
+        "- OK\n  " \
+        "- remove association {group:#{group_name} <-> host:#{host_name}}...\n    " \
+        "- OK\n  " \
+        "- add automatic association {group:ungrouped <-> host:#{host_name}}...\n    " \
+        "- OK\n  " \
+        "- all OK\n" \
         "Succeeded.\n"
       expected(actual, desired)
-      # rubocop:enable Metrics/LineLength
-
       # We should have the correct group associations
       group = @db.models[:group].find(name: group_name)
       hosts = group.hosts_dataset
       expect(hosts.count).to eq(0)
     end
 
+    #------------------------
+    it 'group rmhost GROUP HOST --dry-run should not remove membership or add ungrouped' do
+      host_name = 'test1'
+      group_name = 'group1'
+      runner { @app.start(%W[host add #{host_name}]) }
+      runner { @app.start(%W[group add #{group_name}]) }
+      runner { @app.start(%W[group addhost #{group_name} #{host_name}]) }
+
+      actual = runner { @app.start(%W[group rmhost #{group_name} #{host_name} --dry-run]) }
+
+      expect(actual[:unexpected]).to eq(false)
+      expect(actual[:aborted]).to eq(false)
+      expect(actual[:STDOUT]).to include('Dry run complete. No changes applied.')
+      group = @db.models[:group].find(name: group_name)
+      host = @db.models[:host].find(name: host_name)
+      expect(group.hosts_dataset[name: host_name]).not_to be_nil
+      expect(host.groups_dataset[name: 'ungrouped']).to be_nil
+    end
+
     #------------------------
     it 'GROUP HOST ... should warn about non-existing associations' do
       # 1. Should warn that the association doesn't exist.
@@ -123,28 +123,27 @@ RSpec.describe Moose::Inventory::Cli::Group do
 
       host_name = 'test_host'
       group_name = 'test_group'
-      runner { @app.start(%W(host add #{host_name})) }
-      runner { @app.start(%W(group add #{group_name})) }
-      runner { @app.start(%W(group addhost #{host_name})) }
+      runner { @app.start(%W[host add #{host_name}]) }
+      runner { @app.start(%W[group add #{group_name}]) }
+      runner { @app.start(%W[group addhost #{host_name}]) }
 
       actual = runner do
-        @app.start(%W(group rmhost #{group_name} #{host_name}))
+        @app.start(%W[group rmhost #{group_name} #{host_name} --yes])
       end
 
-      # rubocop:disable Metrics/LineLength
       desired = { aborted: false }
       desired[:STDOUT] =
-        "Dissociate group '#{group_name}' from host(s) '#{host_name}':\n"\
-        "  - retrieve group \'#{group_name}\'...\n"\
-        "    - OK\n"\
-        "  - remove association {group:#{group_name} <-> host:#{host_name}}...\n"\
-        "    - doesn't exist, skipping.\n"\
-        "    - OK\n"\
-        "  - all OK\n"\
+        "Dissociate group '#{group_name}' from host(s) '#{host_name}':\n  " \
+        "- retrieve group '#{group_name}'...\n    " \
+        "- OK\n  " \
+        "- remove association {group:#{group_name} <-> host:#{host_name}}...\n    " \
+        "- doesn't exist, skipping.\n    " \
+        "- OK\n  " \
+        "- all OK\n" \
         "Succeeded, with warnings.\n"
       desired[:STDERR] =
-        "WARNING: Association {group:#{group_name} <-> host:#{host_name}} "\
-          "doesn't exist, skipping.\n"
+        "WARNING: Association {group:#{group_name} <-> host:#{host_name}} " \
+        "doesn't exist, skipping.\n"
 
       expected(actual, desired)
     end
@@ -154,9 +153,9 @@ RSpec.describe Moose::Inventory::Cli::Group do
       host_name = 'test_host'
       group_name = 'ungrouped'
 
-      runner { @app.start(%W(host add #{name})) } # <- auto creates the association with ungrouped
+      runner { @app.start(%W[host add #{name}]) } # <- auto creates the association with ungrouped
 
-      actual = runner { @app.start(%W(group rmhost #{group_name} #{host_name})) }
+      actual = runner { @app.start(%W[group rmhost #{group_name} #{host_name} --yes]) }
 
       desired = { aborted: true }
       desired[:STDERR] =
@@ -165,41 +164,39 @@ RSpec.describe Moose::Inventory::Cli::Group do
     end
 
     #------------------------
-    it 'GROUP HOST1 HOST2 ... should dissociate the group from'\
-      ' multiple hosts at once' do
+    it 'GROUP HOST1 HOST2 ... should dissociate the group from ' \
+       'multiple hosts at once' do
       # 1. Should dissociate hosts from the group
       # 2. Should add each host to the 'ungrouped' automatic group
       #    if it has no other groups.
 
       group_name = 'test_group'
-      host_names = %w(test_host1 test_host2 test_host3)
+      host_names = %w[test_host1 test_host2 test_host3]
 
-      runner { @app.start(%W(group add #{group_name})) }
-      runner { @app.start(%W(group addhost #{group_name}) + host_names) }
+      runner { @app.start(%W[group add #{group_name}]) }
+      runner { @app.start(%W[group addhost #{group_name}] + host_names) }
 
       actual = runner do
-        @app.start(%W(group rmhost #{group_name}) + host_names)
+        @app.start(%W[group rmhost #{group_name} --yes] + host_names)
       end
 
       # @console.out(actual, 'y')
       desired = { aborted: false }
       desired[:STDOUT] =
-        "Dissociate group '#{group_name}' from host(s) '#{host_names.join(',')}':\n"\
-        "  - retrieve group \'#{group_name}\'...\n"\
-        "    - OK\n"
+        "Dissociate group '#{group_name}' from host(s) '#{host_names.join(',')}':\n  " \
+        "- retrieve group '#{group_name}'...\n    " \
+        "- OK\n"
       host_names.each do |host|
         desired[:STDOUT] = desired[:STDOUT] +
-                           "  - remove association {group:#{group_name} <-> host:#{host}}...\n"\
-                           "    - OK\n"\
-                           "  - add automatic association {group:ungrouped <-> host:#{host}}...\n"\
-                           "    - OK\n"\
+                           "  - remove association {group:#{group_name} <-> host:#{host}}...\n    " \
+                           "- OK\n  " \
+                           "- add automatic association {group:ungrouped <-> host:#{host}}...\n    " \
+                           "- OK\n" \
       end
       desired[:STDOUT] = desired[:STDOUT] +
-                         "  - all OK\n"\
+                         "  - all OK\n" \
                          "Succeeded.\n"
       expected(actual, desired)
-      # rubocop:enable Metrics/LineLength
-
       # We should have the correct group associations
       group = @db.models[:group].find(name: group_name)
       hosts = group.hosts_dataset
@@ -210,3 +207,4 @@ RSpec.describe Moose::Inventory::Cli::Group do
     end
   end
 end
+# rubocop:enable Metrics/BlockLength

data/spec/lib/moose_inventory/cli/group_rmvar_spec.rb

@@ -1,48 +1,29 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/BlockLength
 require 'spec_helper'
 
-# TODO: the usual respond_to? method doesn't seem to work on Thor objects.
 # Why not? For now, we'll check against instance_methods.
 
 RSpec.describe Moose::Inventory::Cli::Group do
   before(:all) do
-    # Set up the configuration object
-    @mockarg_parts = {
-      config:  File.join(spec_root, 'config/config.yml'),
-      format:  'yaml',
-      env:     'test',
-    }
-
-    @mockargs = []
-    @mockarg_parts.each do |key, val|
-      @mockargs << "--#{key}"
-      @mockargs << val
-    end
-
-    @config = Moose::Inventory::Config
-    @config.init(@mockargs)
-
-    @db = Moose::Inventory::DB
-    @db.init if @db.db.nil?
-
-    @console = Moose::Inventory::Cli::Formatter
-    @group = Moose::Inventory::Cli::Group
-    @app = Moose::Inventory::Cli::Application
+    setup_cli_harness(command_class: Moose::Inventory::Cli::Group, command_ivar: :@group)
   end
 
   before(:each) do
-    @db.reset
+    reset_cli_harness
   end
 
   describe 'rmvar' do
     it 'should be responsive' do
-      result = @group.instance_methods(false).include?(:rmvar)
+      result = @group.method_defined?(:rmvar, false)
       expect(result).to eq(true)
     end
 
     #-----------------
     it '<missing args> ... should abort with an error' do
       actual = runner  do
-        @app.start(%w(group rmvar))
+        @app.start(%w[group rmvar])
       end
 
       # Check output
@@ -56,16 +37,16 @@ RSpec.describe Moose::Inventory::Cli::Group do
       group_name = 'does-not-exist'
       var_name = 'foo=bar'
       actual = runner do
-        @app.start(%W(group rmvar #{group_name} #{var_name}))
+        @app.start(%W[group rmvar #{group_name} #{var_name} --yes])
       end
 
       # Check output
       desired = { aborted: true }
       desired[:STDOUT] =
-        "Remove variable(s) '#{var_name}' from group '#{group_name}':\n"\
-        "  - retrieve group '#{group_name}'...\n"
+        "Remove variable(s) '#{var_name}' from group '#{group_name}':\n  " \
+        "- retrieve group '#{group_name}'...\n"
       desired[:STDERR] =
-        "An error occurred during a transaction, any changes have been rolled back.\n"\
+        "An error occurred during a transaction, any changes have been rolled back.\n" \
         "ERROR: The group '#{group_name}' does not exist.\n"
       expected(actual, desired)
     end
@@ -77,44 +58,57 @@ RSpec.describe Moose::Inventory::Cli::Group do
 
       group_name = 'test1'
       @db.models[:group].create(name: group_name)
-
-      var = { name: 'foo', value: 'bar' }
-      cases = %w(
+      cases = %w[
         =bar
         foo=bar=
         =foo=bar
         foo=bar=extra
-      )
+      ]
 
       cases.each do |args|
         actual = runner do
-          @app.start(%W(group rmvar #{group_name} #{args}))
+          @app.start(%W[group rmvar #{group_name} #{args} --yes])
         end
         # @console.out(actual,'p')
 
         desired = { aborted: true }
         desired[:STDOUT] =
-          "Remove variable(s) '#{args}' from group '#{group_name}':\n"\
-          "  - retrieve group '#{group_name}'...\n"\
-          "    - OK\n"\
-          "  - remove variable '#{args}'...\n"
+          "Remove variable(s) '#{args}' from group '#{group_name}':\n  " \
+          "- retrieve group '#{group_name}'...\n    " \
+          "- OK\n  " \
+          "- remove variable '#{args}'...\n"
         desired[:STDERR] =
-          "An error occurred during a transaction, any changes have been rolled back.\n"\
+          "An error occurred during a transaction, any changes have been rolled back.\n" \
           "ERROR: Incorrect format in {#{args}}. Expected 'key' or 'key=value'.\n"
 
         expected(actual, desired)
       end
     end
 
+    #------------------------
+    it 'GROUP key --dry-run should not remove the group variable' do
+      group_name = 'group_test'
+      @db.models[:group].create(name: group_name)
+      runner { @app.start(%W[group addvar #{group_name} var1=val1]) }
+
+      actual = runner { @app.start(%W[group rmvar #{group_name} var1 --dry-run]) }
+
+      expect(actual[:unexpected]).to eq(false)
+      expect(actual[:aborted]).to eq(false)
+      expect(actual[:STDOUT]).to include('Dry run complete. No changes applied.')
+      group = @db.models[:group].find(name: group_name)
+      expect(group.groupvars_dataset[name: 'var1']).not_to be_nil
+    end
+
     #------------------------
     it 'GROUP <valid args> ... should remove the group variable' do
       group_name = 'group_test'
       var = { name: 'foo', value: 'bar' }
-      cases = %W(
+      cases = %W[
         #{var[:name]}
         #{var[:name]}=
         #{var[:name]}=#{var[:value]}
-      )
+      ]
       cases.each do |example|
         # reset the db
         @db.reset
@@ -122,24 +116,24 @@ RSpec.describe Moose::Inventory::Cli::Group do
         # Add an initial group and groupvar
         @db.models[:group].create(name: group_name)
         runner do
-          @app.start(%W(group addvar #{group_name} #{var[:name]}=#{var[:value]}))
+          @app.start(%W[group addvar #{group_name} #{var[:name]}=#{var[:value]}])
         end
 
         # Try to remove the groupvar using the case example valid args
         actual = runner do
-          @app.start(%W(group rmvar #{group_name} #{example}))
+          @app.start(%W[group rmvar #{group_name} #{example} --yes])
         end
         # @console.out(actual,'p')
 
         # Check the output
         desired = { aborted: false }
         desired[:STDOUT] =
-          "Remove variable(s) '#{example}' from group '#{group_name}':\n"\
-          "  - retrieve group '#{group_name}'...\n"\
-          "    - OK\n"\
-          "  - remove variable '#{example}'...\n"\
-          "    - OK\n"\
-          "  - all OK\n"\
+          "Remove variable(s) '#{example}' from group '#{group_name}':\n  " \
+          "- retrieve group '#{group_name}'...\n    " \
+          "- OK\n  " \
+          "- remove variable '#{example}'...\n    " \
+          "- OK\n  " \
+          "- all OK\n" \
           "Succeeded.\n"
 
         # @console.out(desired,'p')
@@ -160,36 +154,35 @@ RSpec.describe Moose::Inventory::Cli::Group do
       group_name = 'test_group'
       varsarray  = [
         { name: 'var1', value: 'val1' },
-        { name: 'var2', value: 'val2' },
+        { name: 'var2', value: 'val2' }
       ]
 
-      vars = []
-      varsarray.each do |var|
-        vars << "#{var[:name]}=#{var[:value]}"
+      vars = varsarray.map do |var|
+        "#{var[:name]}=#{var[:value]}"
       end
 
       @db.models[:group].create(name: group_name)
-      actual = runner do
-        @app.start(%W(group addvar #{group_name}) + vars)
+      runner do
+        @app.start(%W[group addvar #{group_name}] + vars)
       end
 
       actual = runner do
-        @app.start(%W(group rmvar #{group_name}) + vars)
+        @app.start(%W[group rmvar #{group_name} --yes] + vars)
       end
       # @console.out(actual,'y')
 
       desired = { aborted: false }
       desired[:STDOUT] =
-        "Remove variable(s) '#{vars.join(',')}' from group '#{group_name}':\n"\
-        "  - retrieve group '#{group_name}'...\n"\
-        "    - OK\n"
+        "Remove variable(s) '#{vars.join(',')}' from group '#{group_name}':\n  " \
+        "- retrieve group '#{group_name}'...\n    " \
+        "- OK\n"
       vars.each do |var|
         desired[:STDOUT] = desired[:STDOUT] +
-                           "  - remove variable '#{var}'...\n"\
-                           "    - OK\n"
+                           "  - remove variable '#{var}'...\n    " \
+                           "- OK\n"
       end
       desired[:STDOUT] = desired[:STDOUT] +
-                         "  - all OK\n"\
+                         "  - all OK\n" \
                          "Succeeded.\n"
       expected(actual, desired)
 
@@ -200,3 +193,4 @@ RSpec.describe Moose::Inventory::Cli::Group do
     end
   end
 end
+# rubocop:enable Metrics/BlockLength

data/spec/lib/moose_inventory/cli/group_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 require_relative 'group_add_spec'

data/spec/lib/moose_inventory/cli/helpers_spec.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# rubocop:disable Metrics/BlockLength
+RSpec.describe Moose::Inventory::Cli::Helpers do
+  subject(:helper) { helper_class.new }
+
+  let(:helper_class) do
+    Class.new do
+      include Moose::Inventory::Cli::Helpers
+    end
+  end
+
+  let(:inventory_context) { instance_double(Moose::Inventory::InventoryContext) }
+  let(:automatic_group) { instance_double('AutomaticGroup') }
+
+  before do
+    helper.instance_variable_set(:@inventory_context, inventory_context)
+    allow(inventory_context).to receive(:automatic_group).and_return(automatic_group)
+  end
+
+  describe 'small helper methods' do
+    it 'checks whether an association dataset contains a named record' do
+      dataset = instance_double('Dataset')
+
+      expect(helper.send(:association_exists?, nil, 'alpha')).to eq(false)
+      allow(dataset).to receive(:[]).with(name: 'alpha').and_return(nil)
+      expect(helper.send(:association_exists?, dataset, 'alpha')).to eq(false)
+      allow(dataset).to receive(:[]).with(name: 'beta').and_return({ name: 'beta' })
+      expect(helper.send(:association_exists?, dataset, 'beta')).to eq(true)
+    end
+
+    it 'converts exceptions to strings' do
+      expect(helper.send(:exception_to_s, RuntimeError.new('boom'))).to eq('boom')
+    end
+
+    it 'returns the automatic group through the inventory context' do
+      expect(helper.send(:automatic_group)).to eq(automatic_group)
+    end
+  end
+
+  describe 'run_group_relation_transaction' do
+    it 'prints the heading and success marker for a successful transaction' do
+      allow(Moose::Inventory::DB).to receive(:transaction).and_yield
+      expect(Moose::Inventory::Cli::Formatter).to receive(:puts).with(2, '- all OK')
+
+      result = nil
+      actual = runner do
+        result = helper.send(:run_group_relation_transaction, heading: 'Heading') { :done }
+      end
+
+      expect(result).to eq(:done)
+      expected(actual, aborted: false, STDOUT: "Heading\n", STDERR: '')
+    end
+
+    it 'aborts with the Moose exception message when no custom handler is supplied' do
+      error = Moose::Inventory::DB::MooseDBException.new('boom')
+      allow(Moose::Inventory::DB).to receive(:transaction).and_raise(error)
+      allow(Moose::Inventory::DB).to receive(:exceptions).and_return({ moose: Moose::Inventory::DB::MooseDBException })
+
+      actual = runner do
+        helper.send(:run_group_relation_transaction, heading: 'Heading') { :done }
+      end
+
+      expected(actual, aborted: true, STDOUT: '', STDERR: "ERROR: boom\n")
+    end
+
+    it 'uses the custom Moose exception handler when provided' do
+      error = Moose::Inventory::DB::MooseDBException.new('boom')
+      allow(Moose::Inventory::DB).to receive(:transaction).and_raise(error)
+      allow(Moose::Inventory::DB).to receive(:exceptions).and_return({ moose: Moose::Inventory::DB::MooseDBException })
+
+      actual = runner do
+        helper.send(
+          :run_group_relation_transaction,
+          heading: 'Heading',
+          on_error: ->(e) { "wrapped #{e.message}" }
+        ) { :done }
+      end
+
+      expected(actual, aborted: true, STDOUT: '', STDERR: "ERROR: wrapped boom\n")
+    end
+  end
+
+  describe 'automatic-group helpers' do
+    it 'removes the automatic group from a host when present' do
+      host = instance_double('Host')
+      dataset = instance_double('Dataset')
+      ungrouped = instance_double('Group')
+      allow(host).to receive(:groups_dataset).and_return(dataset)
+      allow(dataset).to receive(:[]).with(name: 'ungrouped').and_return(ungrouped)
+      expect(Moose::Inventory::Cli::Formatter).to receive(:puts).with(2, 'remove auto')
+      expect(host).to receive(:remove_group).with(ungrouped)
+      expect(Moose::Inventory::Cli::Formatter).to receive(:puts).with(4, '- OK')
+
+      helper.send(:remove_automatic_group_from_host, host, indent: 2, message: 'remove auto')
+    end
+
+    it 'does nothing when the automatic group is not present' do
+      host = instance_double('Host')
+      dataset = instance_double('Dataset')
+      allow(host).to receive(:groups_dataset).and_return(dataset)
+      allow(dataset).to receive(:[]).with(name: 'ungrouped').and_return(nil)
+
+      expect(Moose::Inventory::Cli::Formatter).not_to receive(:puts)
+      expect(host).not_to receive(:remove_group)
+
+      helper.send(:remove_automatic_group_from_host, host, indent: 2, message: 'remove auto')
+    end
+
+    it 'adds the automatic group when the last non-automatic group is removed' do
+      host = instance_double('Host')
+      dataset = instance_double('Dataset', count: 1)
+      allow(host).to receive(:groups_dataset).and_return(dataset)
+      expect(Moose::Inventory::Cli::Formatter).to receive(:puts).with(2, 'add auto')
+      expect(host).to receive(:add_group).with(automatic_group)
+      expect(Moose::Inventory::Cli::Formatter).to receive(:puts).with(4, '- OK')
+
+      helper.send(:add_automatic_group_to_host_if_last_group, host, indent: 2, message: 'add auto')
+    end
+
+    it 'adds the automatic group when a host has no groups' do
+      host = instance_double('Host')
+      dataset = instance_double('Dataset', count: 0)
+      allow(host).to receive(:groups_dataset).and_return(dataset)
+      expect(Moose::Inventory::Cli::Formatter).to receive(:puts).with(2, 'add auto')
+      expect(host).to receive(:add_group).with(automatic_group)
+      expect(Moose::Inventory::Cli::Formatter).to receive(:puts).with(4, '- OK')
+
+      helper.send(:add_automatic_group_to_host_if_no_groups, host, indent: 2, message: 'add auto')
+    end
+
+    it 'does nothing when the group count does not match the requested threshold' do
+      host = instance_double('Host')
+      dataset = instance_double('Dataset', count: 2)
+      allow(host).to receive(:groups_dataset).and_return(dataset)
+
+      expect(Moose::Inventory::Cli::Formatter).not_to receive(:puts)
+      expect(host).not_to receive(:add_group)
+
+      helper.send(:add_automatic_group_to_host_if_group_count, host, 1, indent: 2, message: 'add auto')
+    end
+  end
+end
+# rubocop:enable Metrics/BlockLength