moose-inventory 1.0.9 → 2.1

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

@@ -1,51 +1,34 @@
+# 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)
-
-    @console = Moose::Inventory::Cli::Formatter
-
-    @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 'rm' do
     #---------------
     it 'Group.rm() should be responsive' do
-      result = @group.instance_methods(false).include?(:rm)
+      result = @group.method_defined?(:rm, false)
       expect(result).to eq(true)
     end
 
     #---------------
     it '<missing argument> ... should abort with an error' do
-      actual = runner { @app.start(%w(host rm)) }
+      actual = runner { @app.start(%w[host rm]) }
 
       # Check output
       desired = { aborted: true, STDERR: '', STDOUT: '' }
@@ -55,7 +38,7 @@ RSpec.describe Moose::Inventory::Cli::Group do
 
     # --------------------
     it 'ungrouped ... should abort with an error' do
-      actual = runner { @app.start(%w(group rm ungrouped)) }
+      actual = runner { @app.start(%w[group rm ungrouped]) }
 
       # Check output
       desired = { aborted: true }
@@ -73,16 +56,16 @@ RSpec.describe Moose::Inventory::Cli::Group do
 
       # no items in the db
       group_name = 'fake'
-      actual = runner { @app.start(%W(group rm #{group_name})) }
+      actual = runner { @app.start(%W[group rm #{group_name} --yes]) }
 
       # @console.out(actual,'y')
       desired = {}
       desired[:STDOUT] =
-        "Remove group '#{group_name}':\n"\
-        "  - Retrieve group '#{group_name}'...\n"\
-        "    - No such group, skipping.\n"\
-        "    - OK\n"\
-        "  - All OK\n"\
+        "Remove group '#{group_name}':\n  " \
+        "- Retrieve group '#{group_name}'...\n    " \
+        "- No such group, skipping.\n    " \
+        "- OK\n  " \
+        "- All OK\n" \
         "Succeeded, with warnings.\n"
       desired[:STDERR] =
         "WARNING: Group '#{group_name}' does not exist, skipping.\n"
@@ -95,17 +78,17 @@ RSpec.describe Moose::Inventory::Cli::Group do
       group_name = 'test1'
       @db.models[:group].create(name: group_name)
 
-      actual = runner { @app.start(%W(group rm #{group_name})) }
+      actual = runner { @app.start(%W[group rm #{group_name} --yes]) }
 
       # Check output
       desired = {}
       desired[:STDOUT] =
-        "Remove group '#{group_name}':\n"\
-        "  - Retrieve group '#{group_name}'...\n"\
-        "    - OK\n"\
-        "  - Destroy group '#{group_name}'...\n"\
-        "    - OK\n"\
-        "  - All OK\n"\
+        "Remove group '#{group_name}':\n  " \
+        "- Retrieve group '#{group_name}'...\n    " \
+        "- OK\n  " \
+        "- Destroy group '#{group_name}'...\n    " \
+        "- OK\n  " \
+        "- All OK\n" \
         "Succeeded.\n"
       expected(actual, desired)
 
@@ -114,12 +97,68 @@ RSpec.describe Moose::Inventory::Cli::Group do
       expect(group).to be_nil
     end
 
+    #---------------
+    it 'GROUP without --yes or --dry-run should abort before deleting' do
+      group_name = 'group1'
+      @db.models[:group].create(name: group_name)
+
+      actual = runner { @app.start(%W[group rm #{group_name}]) }
+
+      desired = {
+        aborted: true,
+        STDOUT: '',
+        STDERR: "ERROR: group rm #{group_name} is destructive. Re-run with --yes to confirm, " \
+                "or use --dry-run to preview.\n"
+      }
+      expected(actual, desired)
+      expect(@db.models[:group].find(name: group_name)).not_to be_nil
+    end
+
+    #---------------
+    it 'GROUP --dry-run should show planned removal without deleting the group' do
+      group_name = 'test1'
+      @db.models[:group].create(name: group_name)
+
+      actual = runner { @app.start(%W[group rm #{group_name} --dry-run]) }
+
+      desired = {}
+      desired[:STDOUT] =
+        "Remove group '#{group_name}':\n  " \
+        "- Retrieve group '#{group_name}'...\n    " \
+        "- OK\n  " \
+        "- Destroy group '#{group_name}'...\n    " \
+        "- OK\n  " \
+        "- All OK\n" \
+        "Dry run complete. No changes applied.\n" \
+        "Succeeded.\n"
+
+      expected(actual, desired)
+      expect(@db.models[:group].find(name: group_name)).not_to be_nil
+    end
+
+    #---------------
+    it 'GROUP --recursive --dry-run should show recursive cleanup without deleting groups' do
+      runner { @app.start(%w[group add parent]) }
+      runner { @app.start(%w[group add child --hosts child-host]) }
+      runner { @app.start(%w[group addchild parent child]) }
+
+      actual = runner { @app.start(%w[group rm --recursive parent --dry-run]) }
+
+      expect(actual[:unexpected]).to eq(false)
+      expect(actual[:aborted]).to eq(false)
+      expect(actual[:STDOUT]).to include("- Recursively delete orphaned group 'child'...\n")
+      expect(actual[:STDOUT]).to include('Dry run complete. No changes applied.')
+      expect(@db.models[:group].find(name: 'parent')).not_to be_nil
+      expect(@db.models[:group].find(name: 'child')).not_to be_nil
+      host = @db.models[:host].find(name: 'child-host')
+      expect(host.groups_dataset[name: 'ungrouped']).to be_nil
+    end
     #---------------
     it "GROUP ... should handle the automatic 'ungrouped' group for associated hosts" do
       host_name = 'test-host1'
       group_name = 'test-group1'
 
-      tmp = runner { @app.start(%W(group add #{group_name} --hosts #{host_name})) }
+      tmp = runner { @app.start(%W[group add #{group_name} --hosts #{host_name}]) }
       expect(tmp[:unexpected]).to eq(false)
       expect(tmp[:aborted]).to eq(false)
       host = @db.models[:host].find(name: host_name)
@@ -128,21 +167,21 @@ RSpec.describe Moose::Inventory::Cli::Group do
       expect(groups_ds[name: 'ungrouped']).to be_nil # Shouldn't be ungrouped
 
       # Now do the rm
-      actual = runner { @app.start(%W(group rm #{group_name})) }
+      actual = runner { @app.start(%W[group rm #{group_name} --yes]) }
 
       # @console.out(actual)
 
       # Check output
       desired = {}
       desired[:STDOUT] =
-        "Remove group '#{group_name}':\n"\
-        "  - Retrieve group '#{group_name}'...\n"\
-        "    - OK\n"\
-        "  - Adding automatic association {group:ungrouped <-> host:#{host_name}}...\n"\
-        "    - OK\n"\
-        "  - Destroy group '#{group_name}'...\n"\
-        "    - OK\n"\
-        "  - All OK\n"\
+        "Remove group '#{group_name}':\n  " \
+        "- Retrieve group '#{group_name}'...\n    " \
+        "- OK\n  " \
+        "- Adding automatic association {group:ungrouped <-> host:#{host_name}}...\n    " \
+        "- OK\n  " \
+        "- Destroy group '#{group_name}'...\n    " \
+        "- OK\n  " \
+        "- All OK\n" \
         "Succeeded.\n"
       expected(actual, desired)
 
@@ -159,26 +198,26 @@ RSpec.describe Moose::Inventory::Cli::Group do
 
     #---------------
     it 'GROUP1 GROUP2 ... should remove multiple groups' do
-      names = %w(group1 group2 group3)
+      names = %w[group1 group2 group3]
       names.each do |name|
         @db.models[:group].create(name: name)
       end
 
-      actual = runner { @app.start(%w(group rm) + names) }
+      actual = runner { @app.start(%w[group rm --yes] + names) }
 
       # Check output
       desired = { STDOUT: '' }
       names.each do |name|
         # Check output
         desired[:STDOUT] = desired[:STDOUT] +
-                           "Remove group '#{name}':\n"\
-                           "  - Retrieve group '#{name}'...\n"\
-                           "    - OK\n"\
-                           "  - Destroy group '#{name}'...\n"\
-                           "    - OK\n"\
-                           "  - All OK\n"
+                           "Remove group '#{name}':\n  " \
+                           "- Retrieve group '#{name}'...\n    " \
+                           "- OK\n  " \
+                           "- Destroy group '#{name}'...\n    " \
+                           "- OK\n  " \
+                           "- All OK\n"
       end
-      desired[:STDOUT] = desired[:STDOUT] + "Succeeded.\n"
+      desired[:STDOUT] = "#{desired[:STDOUT]}Succeeded.\n"
       expected(actual, desired)
 
       # Check db
@@ -189,24 +228,24 @@ RSpec.describe Moose::Inventory::Cli::Group do
     #---------------
     it 'GROUP ... should remove GROUP, where GROUP has an associated parent.' do
       @db.models[:group].create(name: 'parent')
-      runner { @app.start(%w(group addchild parent child)) }
+      runner { @app.start(%w[group addchild parent child]) }
 
-      actual = runner { @app.start(%w(group rm child)) }
+      actual = runner { @app.start(%w[group rm child --yes]) }
 
       # Check output
       desired = { STDOUT: '' }
       # Check output
       desired[:STDOUT] = desired[:STDOUT] +
-                         "Remove group 'child':\n"\
-                         "  - Retrieve group 'child'...\n"\
-                         "    - OK\n"\
-                         "  - Remove association {group:child <-> group:parent}...\n"\
-                         "    - OK\n"\
-                         "  - Destroy group 'child'...\n"\
-                         "    - OK\n"\
-                         "  - All OK\n"
-
-      desired[:STDOUT] = desired[:STDOUT] + "Succeeded.\n"
+                         "Remove group 'child':\n  " \
+                         "- Retrieve group 'child'...\n    " \
+                         "- OK\n  " \
+                         "- Remove association {group:child <-> group:parent}...\n    " \
+                         "- OK\n  " \
+                         "- Destroy group 'child'...\n    " \
+                         "- OK\n  " \
+                         "- All OK\n"
+
+      desired[:STDOUT] = "#{desired[:STDOUT]}Succeeded.\n"
       expected(actual, desired)
 
       # Check db
@@ -217,29 +256,70 @@ RSpec.describe Moose::Inventory::Cli::Group do
     #---------------
     it 'GROUP ... should remove GROUP, where GROUP has an associated child.' do
       @db.models[:group].create(name: 'parent')
-      runner { @app.start(%w(group addchild parent child)) }
+      runner { @app.start(%w[group addchild parent child]) }
 
-      actual = runner { @app.start(%w(group rm parent)) }
+      actual = runner { @app.start(%w[group rm parent --yes]) }
 
       # Check output
       desired = { STDOUT: '' }
       # Check output
       desired[:STDOUT] = desired[:STDOUT] +
-                         "Remove group 'parent':\n"\
-                         "  - Retrieve group 'parent'...\n"\
-                         "    - OK\n"\
-                         "  - Remove association {group:parent <-> group:child}...\n"\
-                         "    - OK\n"\
-                         "  - Destroy group 'parent'...\n"\
-                         "    - OK\n"\
-                         "  - All OK\n"
-
-      desired[:STDOUT] = desired[:STDOUT] + "Succeeded.\n"
+                         "Remove group 'parent':\n  " \
+                         "- Retrieve group 'parent'...\n    " \
+                         "- OK\n  " \
+                         "- Remove association {group:parent <-> group:child}...\n    " \
+                         "- OK\n  " \
+                         "- Destroy group 'parent'...\n    " \
+                         "- OK\n  " \
+                         "- All OK\n"
+
+      desired[:STDOUT] = "#{desired[:STDOUT]}Succeeded.\n"
       expected(actual, desired)
 
       # Check db
       groups = @db.models[:group].all
       expect(groups.count).to eq(1)
     end
+
+    #---------------
+    it 'GROUP --recursive ... should remove orphaned child groups recursively' do
+      runner { @app.start(%w[group add parent]) }
+      runner { @app.start(%w[group add child --hosts child-host]) }
+      runner { @app.start(%w[group add grandchild]) }
+      runner { @app.start(%w[group addchild parent child]) }
+      runner { @app.start(%w[group addchild child grandchild]) }
+
+      actual = runner { @app.start(%w[group rm --recursive parent --yes]) }
+
+      expect(actual[:unexpected]).to eq(false)
+      expect(actual[:aborted]).to eq(false)
+      expect(actual[:STDOUT]).to include("- Recursively delete orphaned group 'child'...\n")
+      expect(actual[:STDOUT]).to include("- Recursively delete orphaned group 'grandchild'...\n")
+
+      %w[parent child grandchild].each do |name|
+        expect(@db.models[:group].find(name: name)).to be_nil
+      end
+
+      host = @db.models[:host].find(name: 'child-host')
+      expect(host.groups_dataset[name: 'ungrouped']).not_to be_nil
+    end
+
+    #---------------
+    it 'GROUP --recursive ... should not remove child groups with another parent' do
+      runner { @app.start(%w[group add parent other-parent]) }
+      runner { @app.start(%w[group addchild parent child]) }
+      runner { @app.start(%w[group addchild other-parent child]) }
+
+      actual = runner { @app.start(%w[group rm --recursive parent --yes]) }
+
+      expect(actual[:unexpected]).to eq(false)
+      expect(actual[:aborted]).to eq(false)
+      expect(@db.models[:group].find(name: 'parent')).to be_nil
+
+      child = @db.models[:group].find(name: 'child')
+      expect(child).not_to be_nil
+      expect(child.parents_dataset[name: 'other-parent']).not_to be_nil
+    end
   end
 end
+# rubocop:enable Metrics/BlockLength

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

@@ -1,15 +1,17 @@
+# 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',
+      config: File.join(spec_root, 'config/config.yml'),
+      format: 'yaml',
+      env: 'test'
     }
 
     @mockargs = []
@@ -39,14 +41,14 @@ RSpec.describe Moose::Inventory::Cli::Group do
   describe 'rmchild' do
     #------------------------
     it 'Group.rmchild() should be responsive' do
-      result = @group.instance_methods(false).include?(:rmchild)
+      result = @group.method_defined?(:rmchild, false)
       expect(result).to eq(true)
     end
 
     #------------------------
     it '<missing args> ... should abort with an error' do
       actual = runner  do
-        @app.start(%w(group addchild))
+        @app.start(%w[group addchild])
       end
 
       # @console.out(actual, 'y')
@@ -63,7 +65,7 @@ RSpec.describe Moose::Inventory::Cli::Group do
       child_name = 'fake'
 
       actual = runner do
-        @app.start(%W(group addchild #{parent_name} #{child_name}))
+        @app.start(%W[group addchild #{parent_name} #{child_name}])
       end
 
       # @console.out(actual, 'y')
@@ -79,7 +81,7 @@ RSpec.describe Moose::Inventory::Cli::Group do
       child_name = 'ungrouped'
 
       actual = runner do
-        @app.start(%W(group rmchild #{parent_name} #{child_name}))
+        @app.start(%W[group rmchild #{parent_name} #{child_name} --yes])
       end
 
       # @console.out(actual, 'y')
@@ -96,17 +98,17 @@ RSpec.describe Moose::Inventory::Cli::Group do
       cname = 'child group'
 
       actual = runner do
-        @app.start(%W(group rmchild #{pname} #{cname}))
+        @app.start(%W[group rmchild #{pname} #{cname} --yes])
       end
 
       # @console.out(actual, 'y')
       # Check output
       desired = { aborted: true }
       desired[:STDOUT] =
-        "Dissociate parent group '#{pname}' from child group(s) '#{cname}':\n"\
-        "  - retrieve group '#{pname}'...\n"
+        "Dissociate parent group '#{pname}' from child group(s) '#{cname}':\n  " \
+        "- retrieve group '#{pname}'...\n"
       desired[:STDERR] =
-        "ERROR: The group '#{pname}' does not exist.\n"\
+        "ERROR: The group '#{pname}' does not exist.\n" \
         "An error occurred during a transaction, any changes have been rolled back.\n"
       expected(actual, desired)
     end
@@ -116,10 +118,10 @@ RSpec.describe Moose::Inventory::Cli::Group do
       pname = 'parent_group'
       cname = 'child group'
 
-      runner { @app.start(%W(group add #{pname} #{cname})) }
+      runner { @app.start(%W[group add #{pname} #{cname}]) }
 
       actual = runner do
-        @app.start(%W(group rmchild #{pname} #{cname}))
+        @app.start(%W[group rmchild #{pname} #{cname} --yes])
       end
 
       # @console.out(actual, 'y')
@@ -127,13 +129,13 @@ RSpec.describe Moose::Inventory::Cli::Group do
       # Check output
       desired = {}
       desired[:STDOUT] =
-        "Dissociate parent group '#{pname}' from child group(s) '#{cname}':\n"\
-        "  - retrieve group '#{pname}'...\n"\
-        "    - OK\n"\
-        "  - remove association {group:#{pname} <-> group:#{cname}}...\n"\
-        "    - doesn't exist, skipping.\n"\
-        "    - OK\n"\
-        "  - all OK\n"\
+        "Dissociate parent group '#{pname}' from child group(s) '#{cname}':\n  " \
+        "- retrieve group '#{pname}'...\n    " \
+        "- OK\n  " \
+        "- remove association {group:#{pname} <-> group:#{cname}}...\n    " \
+        "- doesn't exist, skipping.\n    " \
+        "- OK\n  " \
+        "- all OK\n" \
         "Succeeded, with warnings.\n"
 
       desired[:STDERR] =
@@ -147,11 +149,11 @@ RSpec.describe Moose::Inventory::Cli::Group do
       pname = 'parent_group'
       cname = 'child group'
 
-      runner { @app.start(%W(group add #{pname} #{cname})) }
-      runner { @app.start(%W(group addchild #{pname} #{cname})) }
+      runner { @app.start(%W[group add #{pname} #{cname}]) }
+      runner { @app.start(%W[group addchild #{pname} #{cname}]) }
 
       actual = runner do
-        @app.start(%W(group rmchild #{pname} #{cname}))
+        @app.start(%W[group rmchild #{pname} #{cname} --yes])
       end
 
       # @console.out(actual, 'y')
@@ -159,15 +161,83 @@ RSpec.describe Moose::Inventory::Cli::Group do
       # Check output
       desired = {}
       desired[:STDOUT] =
-        "Dissociate parent group '#{pname}' from child group(s) '#{cname}':\n"\
-        "  - retrieve group '#{pname}'...\n"\
-        "    - OK\n"\
-        "  - remove association {group:#{pname} <-> group:#{cname}}...\n"\
-        "    - OK\n"\
-        "  - all OK\n"\
+        "Dissociate parent group '#{pname}' from child group(s) '#{cname}':\n  " \
+        "- retrieve group '#{pname}'...\n    " \
+        "- OK\n  " \
+        "- remove association {group:#{pname} <-> group:#{cname}}...\n    " \
+        "- OK\n  " \
+        "- all OK\n" \
         "Succeeded.\n"
 
       expected(actual, desired)
     end
+
+    #------------------------
+    it 'GROUP CHILDGROUP --delete-orphans --dry-run should not remove or delete groups' do
+      runner { @app.start(%w[group add parent]) }
+      runner { @app.start(%w[group add child --hosts child-host]) }
+      runner { @app.start(%w[group addchild parent child]) }
+
+      actual = runner do
+        @app.start(%w[group rmchild --delete-orphans parent child --dry-run])
+      end
+
+      expect(actual[:unexpected]).to eq(false)
+      expect(actual[:aborted]).to eq(false)
+      expect(actual[:STDOUT]).to include('Dry run complete. No changes applied.')
+      expect(actual[:STDOUT]).to include("- Recursively delete orphaned group 'child'...
+")
+      parent = @db.models[:group].find(name: 'parent')
+      expect(parent.children_dataset[name: 'child']).not_to be_nil
+      expect(@db.models[:group].find(name: 'child')).not_to be_nil
+      host = @db.models[:host].find(name: 'child-host')
+      expect(host.groups_dataset[name: 'ungrouped']).to be_nil
+    end
+
+    #------------------------
+    it 'GROUP CHILDGROUP --delete-orphans ... should delete orphaned child groups recursively' do
+      runner { @app.start(%w[group add parent]) }
+      runner { @app.start(%w[group add child --hosts child-host]) }
+      runner { @app.start(%w[group add grandchild]) }
+      runner { @app.start(%w[group addchild parent child]) }
+      runner { @app.start(%w[group addchild child grandchild]) }
+
+      actual = runner do
+        @app.start(%w[group rmchild --delete-orphans parent child --yes])
+      end
+
+      expect(actual[:unexpected]).to eq(false)
+      expect(actual[:aborted]).to eq(false)
+      expect(actual[:STDOUT]).to include("- Recursively delete orphaned group 'child'...\n")
+      expect(actual[:STDOUT]).to include("- Recursively delete orphaned group 'grandchild'...\n")
+
+      expect(@db.models[:group].find(name: 'parent')).not_to be_nil
+      %w[child grandchild].each do |name|
+        expect(@db.models[:group].find(name: name)).to be_nil
+      end
+
+      host = @db.models[:host].find(name: 'child-host')
+      expect(host.groups_dataset[name: 'ungrouped']).not_to be_nil
+    end
+
+    #------------------------
+    it 'GROUP CHILDGROUP --delete-orphans ... should preserve child groups with another parent' do
+      runner { @app.start(%w[group add parent other-parent]) }
+      runner { @app.start(%w[group addchild parent child]) }
+      runner { @app.start(%w[group addchild other-parent child]) }
+
+      actual = runner do
+        @app.start(%w[group rmchild --delete-orphans parent child --yes])
+      end
+
+      expect(actual[:unexpected]).to eq(false)
+      expect(actual[:aborted]).to eq(false)
+
+      child = @db.models[:group].find(name: 'child')
+      expect(child).not_to be_nil
+      expect(child.parents_dataset[name: 'parent']).to be_nil
+      expect(child.parents_dataset[name: 'other-parent']).not_to be_nil
+    end
   end
 end
+# rubocop:enable Metrics/BlockLength