moose-inventory 2.0 → 2.1

data/spec/lib/moose_inventory/operations/operation_event_support_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/BlockLength
+require 'spec_helper'
+require 'operations/operation_event_support'
+
+RSpec.describe Moose::Inventory::Operations::OperationEventSupport do
+  subject(:operation) { operation_class.new }
+
+  let(:operation_class) do
+    Class.new do
+      include Moose::Inventory::Operations::OperationEventSupport
+
+      def event(type, payload = {})
+        build_event(type, payload)
+      end
+
+      def append_event(events, type, payload = {})
+        emit(events, type, payload)
+      end
+
+      def result(events:, warning_count: 0)
+        operation_result(events: events, warning_count: warning_count)
+      end
+    end
+  end
+
+  describe '#build_event' do
+    it 'builds structured events with an empty default payload' do
+      event = operation.event(:started)
+
+      expect(event).to be_a(described_class::Event)
+      expect(event.type).to eq(:started)
+      expect(event.payload).to eq({})
+    end
+
+    it 'preserves the provided event payload' do
+      event = operation.event(:created, name: 'testhost')
+
+      expect(event.type).to eq(:created)
+      expect(event.payload).to eq(name: 'testhost')
+    end
+  end
+
+  describe '#emit' do
+    it 'appends a constructed event to the provided collection' do
+      events = []
+
+      result = operation.append_event(events, :warning, name: 'missinggroup')
+      event = events.fetch(0)
+
+      expect(result).to eq(events)
+      expect(event).to be_a(described_class::Event)
+      expect(event.type).to eq(:warning)
+      expect(event.payload).to eq(name: 'missinggroup')
+    end
+  end
+
+  describe '#operation_result' do
+    it 'defaults warning_count to zero' do
+      events = [operation.event(:ok)]
+
+      result = operation.result(events: events)
+
+      expect(result).to be_a(described_class::Result)
+      expect(result.events).to eq(events)
+      expect(result.warning_count).to eq(0)
+      expect(result.warning_count.zero?).to eq(true)
+    end
+
+    it 'preserves an explicit warning_count' do
+      result = operation.result(events: [], warning_count: 2)
+
+      expect(result.warning_count).to eq(2)
+    end
+  end
+end
+# rubocop:enable Metrics/BlockLength

data/spec/lib/moose_inventory/operations/query_inventory_spec.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'inventory_context'
+require 'operations/query_inventory'
+
+RSpec.describe Moose::Inventory::Operations::QueryInventory do
+  before(:all) do
+    @mockargs = [
+      '--config', File.join(spec_root, 'config/config.yml'),
+      '--format', 'yaml',
+      '--env', 'test'
+    ]
+
+    Moose::Inventory::Config.init(@mockargs)
+    @db = Moose::Inventory::DB
+    @db.init if @db.db.nil?
+  end
+
+  before(:each) do
+    @db.reset
+  end
+
+  def operation
+    described_class.new(
+      context: Moose::Inventory::InventoryContext.new(db: @db)
+    )
+  end
+
+  it 'gets host data without rendering output' do
+    host = @db.models[:host].create(name: 'test1')
+    host.add_group(@db.models[:group].find_or_create(name: 'ungrouped'))
+    var = @db.models[:hostvar].create(name: 'foo', value: 'bar')
+    host.add_hostvar(var)
+
+    actual = runner do
+      @result = operation.get_hosts(names: ['test1'])
+    end
+
+    expected(actual, STDOUT: '', STDERR: '')
+    expect(@result).to eq(
+      test1: {
+        groups: ['ungrouped'],
+        hostvars: { foo: 'bar' }
+      }
+    )
+  end
+
+  it 'filters listed hosts by group, tag, and variable' do
+    host = @db.models[:host].create(name: 'web01')
+    other = @db.models[:host].create(name: 'db01')
+    group = @db.models[:group].find_or_create(name: 'web')
+    tag = @db.models[:tag].find_or_create(name: 'prod')
+    host.add_group(group)
+    host.add_tag(tag)
+    other.add_tag(tag)
+    hostvar = @db.models[:hostvar].create(name: 'os', value: 'fedora')
+    other_var = @db.models[:hostvar].create(name: 'os', value: 'debian')
+    host.add_hostvar(hostvar)
+    other.add_hostvar(other_var)
+
+    expect(operation.list_hosts(filters: { groups: ['web'], tags: ['prod'], variables: { 'os' => 'fedora' } })).to eq(
+      web01: {
+        groups: ['web'],
+        tags: ['prod'],
+        hostvars: { os: 'fedora' }
+      }
+    )
+  end
+
+  it 'uses DB-backed host filters without loading all hosts first' do
+    host = @db.models[:host].create(name: 'web01')
+    other = @db.models[:host].create(name: 'db01')
+    group = @db.models[:group].find_or_create(name: 'web')
+    tag = @db.models[:tag].find_or_create(name: 'prod')
+    host.add_group(group)
+    host.add_tag(tag)
+    other.add_tag(tag)
+    host.add_hostvar(@db.models[:hostvar].create(name: 'os', value: 'fedora'))
+    other.add_hostvar(@db.models[:hostvar].create(name: 'os', value: 'debian'))
+    context = Moose::Inventory::InventoryContext.new(db: @db)
+    expect(context).not_to receive(:all_hosts)
+
+    result = described_class.new(context: context).list_hosts(
+      filters: { groups: ['web'], tags: ['prod'], variables: { 'os' => 'fedora' } }
+    )
+
+    expect(result.keys).to eq([:web01])
+  end
+
+  it 'returns no listed hosts when a DB-backed filter references a missing group or tag' do
+    @db.models[:host].create(name: 'web01')
+
+    expect(operation.list_hosts(filters: { groups: ['missing'] })).to eq({})
+    expect(operation.list_hosts(filters: { tags: ['missing'] })).to eq({})
+  end
+
+  it 'applies multiple group filters as AND predicates' do
+    host = @db.models[:host].create(name: 'web01')
+    partial = @db.models[:host].create(name: 'web02')
+    web = @db.models[:group].find_or_create(name: 'web')
+    prod = @db.models[:group].find_or_create(name: 'prod')
+    host.add_group(web)
+    host.add_group(prod)
+    partial.add_group(web)
+
+    expect(operation.list_hosts(filters: { groups: %w[web prod] }).keys).to eq([:web01])
+  end
+
+  it 'gets group data while omitting empty relationship collections' do
+    @db.models[:group].create(name: 'group1')
+
+    expect(operation.get_groups(names: ['group1'])).to eq(
+      group1: {}
+    )
+  end
+
+  it 'lists groups in ansible mode with hosts arrays and vars key' do
+    group = @db.models[:group].create(name: 'group1')
+    var = @db.models[:groupvar].create(name: 'foo', value: 'bar')
+    group.add_groupvar(var)
+
+    expect(operation.list_groups(ansible: true)).to eq(
+      group1: {
+        hosts: [],
+        vars: { foo: 'bar' }
+      }
+    )
+  end
+
+  it 'builds ansible hostvars metadata for host listvars queries' do
+    host = @db.models[:host].create(name: 'test1')
+    host.add_group(@db.models[:group].find_or_create(name: 'ungrouped'))
+    var = @db.models[:hostvar].create(name: 'foo', value: 'bar')
+    host.add_hostvar(var)
+
+    expect(operation.list_host_vars(names: ['test1'], ansible: true)).to eq(
+      foo: 'bar',
+      _meta: {
+        hostvars: {
+          test1: { foo: 'bar' }
+        }
+      }
+    )
+  end
+end

data/spec/lib/moose_inventory/operations/remove_associations_spec.rb

@@ -50,6 +50,41 @@ RSpec.describe Moose::Inventory::Operations::RemoveAssociations do
     expect(host.groups_dataset[name: 'ungrouped']).not_to be_nil
   end
 
+  it 'dry-runs removing groups from a host without removing associations or adding ungrouped' do
+    host = @db.models[:host].create(name: 'host1')
+    group = @db.models[:group].create(name: 'group1')
+    host.add_group(group)
+
+    result = operation.host_from_groups(
+      host: host,
+      host_name: 'host1',
+      group_names: ['group1'],
+      dry_run: true
+    )
+
+    expect(result.warning_count).to eq(0)
+    expect(result.events.map(&:type)).to include(:adding_automatic_group, :dry_run_summary)
+    expect(host.groups_dataset[name: 'group1']).not_to be_nil
+    expect(host.groups_dataset[name: 'ungrouped']).to be_nil
+  end
+
+  it 'dry-runs removing hosts from a group without removing associations or adding ungrouped' do
+    group = @db.models[:group].create(name: 'group1')
+    host = @db.models[:host].create(name: 'host1')
+    group.add_host(host)
+
+    result = operation.group_from_hosts(
+      group: group,
+      group_name: 'group1',
+      host_names: ['host1'],
+      dry_run: true
+    )
+
+    expect(result.warning_count).to eq(0)
+    expect(result.events.map(&:type)).to include(:adding_automatic_group, :dry_run_summary)
+    expect(group.hosts_dataset[name: 'host1']).not_to be_nil
+    expect(host.groups_dataset[name: 'ungrouped']).to be_nil
+  end
   it 'removes hosts from a group and reports missing associations and ungrouped reattachment' do
     group = @db.models[:group].create(name: 'group1')
     host1 = @db.models[:host].create(name: 'host1')

data/spec/lib/moose_inventory/operations/remove_groups_spec.rb

@@ -34,6 +34,27 @@ RSpec.describe Moose::Inventory::Operations::RemoveGroups do
     expect(result.events.map(&:type)).to include(:group_missing)
   end
 
+  it 'returns dry-run events without removing groups or recursive children' do
+    parent = @db.models[:group].create(name: 'parent')
+    child = @db.models[:group].create(name: 'child')
+    host = @db.models[:host].create(name: 'child-host')
+    child.add_host(host)
+    parent.add_child(child)
+
+    result = operation.call(names: ['parent'], recursive: true, dry_run: true)
+
+    expect(result.warning_count).to eq(0)
+    expect(result.events.map(&:type)).to include(
+      :removing_child_association,
+      :recursively_delete_orphaned_group,
+      :adding_automatic_group_to_host,
+      :destroying_group,
+      :dry_run_summary
+    )
+    expect(@db.models[:group].find(name: 'parent')).not_to be_nil
+    expect(@db.models[:group].find(name: 'child')).not_to be_nil
+    expect(host.groups_dataset[name: 'ungrouped']).to be_nil
+  end
   it 'removes groups and recursively cleans orphaned children when requested' do
     parent = @db.models[:group].create(name: 'parent')
     child = @db.models[:group].create(name: 'child')

data/spec/lib/moose_inventory/operations/remove_hosts_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Moose::Inventory::Operations::RemoveHosts do
+  before(:all) do
+    mockargs = [
+      '--config', File.join(spec_root, 'config/config.yml'),
+      '--format', 'yaml',
+      '--env', 'test'
+    ]
+
+    @config = Moose::Inventory::Config
+    @config.init(mockargs)
+
+    @db = Moose::Inventory::DB
+    @db.init if @db.db.nil?
+  end
+
+  before(:each) do
+    @db.reset
+    @context = Moose::Inventory::InventoryContext.new(db: @db)
+    @operation = described_class.new(context: @context)
+  end
+
+  it 'removes an existing host' do
+    host = @db.models[:host].create(name: 'test1')
+    host.add_group(@db.models[:group].find_or_create(name: 'ungrouped'))
+
+    result = @operation.call(names: ['test1'])
+
+    expect(result.warning_count).to eq(0)
+    expect(@db.models[:host].find(name: 'test1')).to be_nil
+    expect(result.events.map(&:type)).to eq(%i[host_started retrieving_host ok destroying_host ok host_complete])
+  end
+
+  it 'returns dry-run events without deleting an existing host' do
+    host = @db.models[:host].create(name: 'test1')
+    host.add_group(@db.models[:group].find_or_create(name: 'ungrouped'))
+
+    result = @operation.call(names: ['test1'], dry_run: true)
+
+    expect(result.warning_count).to eq(0)
+    expect(@db.models[:host].find(name: 'test1')).not_to be_nil
+    expect(result.events.map(&:type)).to eq(%i[host_started retrieving_host ok destroying_host ok host_complete
+                                               dry_run_summary])
+  end
+  it 'returns a warning event when the host does not exist' do
+    result = @operation.call(names: ['fake'])
+
+    expect(result.warning_count).to eq(1)
+    expect(result.events.map(&:type)).to eq(%i[host_started retrieving_host host_missing missing_skipping ok
+                                               host_complete])
+  end
+end

data/spec/lib/moose_inventory/operations/remove_variables_spec.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'inventory_context'
+require 'operations/remove_variables'
+
+RSpec.describe Moose::Inventory::Operations::RemoveVariables do
+  before(:all) do
+    @mockargs = [
+      '--config', File.join(spec_root, 'config/config.yml'),
+      '--format', 'yaml',
+      '--env', 'test'
+    ]
+
+    Moose::Inventory::Config.init(@mockargs)
+    @db = Moose::Inventory::DB
+    @db.init if @db.db.nil?
+  end
+
+  before(:each) do
+    @db.reset
+  end
+
+  def build_operation(entity_type, emitter: nil)
+    described_class.new(
+      context: Moose::Inventory::InventoryContext.new(db: @db),
+      entity_type: entity_type,
+      emitter: emitter
+    )
+  end
+
+  it 'removes host variables and returns structured events without rendering output' do
+    host = @db.models[:host].create(name: 'test1')
+    var = @db.models[:hostvar].create(name: 'var1', value: 'val1')
+    host.add_hostvar(var)
+
+    actual = runner do
+      @result = build_operation(:host).call(name: 'test1', vars: ['var1'])
+    end
+
+    expected(actual, STDOUT: '', STDERR: '')
+    expect(@result.events.map(&:type)).to eq(
+      %i[entity_started retrieving_entity ok removing_variable ok entity_complete]
+    )
+    expect(host.hostvars_dataset.count).to eq(0)
+    expect(@db.models[:hostvar].count).to eq(0)
+  end
+
+  it 'accepts group variable removal by key=value syntax and removes the record' do
+    group = @db.models[:group].create(name: 'testgroup')
+    var = @db.models[:groupvar].create(name: 'var1', value: 'val1')
+    group.add_groupvar(var)
+
+    build_operation(:group).call(name: 'testgroup', vars: ['var1=val1'])
+
+    expect(group.groupvars_dataset.count).to eq(0)
+    expect(@db.models[:groupvar].count).to eq(0)
+  end
+
+  it 'dry-runs removing variables without deleting records' do
+    host = @db.models[:host].create(name: 'test1')
+    var = @db.models[:hostvar].create(name: 'var1', value: 'val1')
+    host.add_hostvar(var)
+
+    result = build_operation(:host).call(name: 'test1', vars: ['var1'], dry_run: true)
+
+    expect(result.events.map(&:type)).to include(:removing_variable, :dry_run_summary)
+    expect(host.hostvars_dataset[name: 'var1']).not_to be_nil
+    expect(@db.models[:hostvar].count).to eq(1)
+  end
+
+  it 'emits partial progress before raising on malformed group variable removal input' do
+    @db.models[:group].create(name: 'testgroup')
+    emitted = []
+    operation = build_operation(:group, emitter: emitted.method(:<<))
+
+    expect do
+      operation.call(name: 'testgroup', vars: ['=broken'])
+    end.to raise_error(Moose::Inventory::DB.exceptions[:moose], /Expected 'key' or 'key=value'/)
+
+    expect(emitted.map(&:type)).to eq(%i[entity_started retrieving_entity ok removing_variable])
+  end
+end

data/spec/shared/shared_config_setup.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
 
 RSpec.shared_context 'shared config init', a: :b do
   before(:all) do
     @mockarg_parts = {
-      config:  File.join(spec_dir, 'config/config.yml'),
-      format:  'yaml',
-      env:     'test',
+      config: File.join(spec_dir, 'config/config.yml'),
+      format: 'yaml',
+      env: 'test'
     }
 
     @mockargs = []

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 if RUBY_VERSION >= '1.9'
   require 'simplecov'
   SimpleCov.formatters = [
@@ -31,34 +33,34 @@ require 'yaml'
 require 'fileutils'
 require 'find'
 require 'moose_inventory'
+require_relative 'support/cli_harness'
 
-RSpec.configure do |config|
-  # config.filter_run focus: true # <- enable to allow test focus
-  config.color = true
-  config.tty = true
-  config.formatter = :progress #:documentation # :progress, :html, :textmate
-  def capture(stream)
+module SpecOutputHelpers
+  def capture(stream, &)
     case stream
     when :STDOUT
-      begin
-        orig = $stdout
-        $stdout = StringIO.new
-        yield
-        result = $stdout.string
-      ensure
-        $stdout = orig
-      end
+      capture_stdout(&)
     when :STDERR
-      begin
-        orig = $stderr
-        $stderr = StringIO.new
-        yield
-        result = $stderr.string
-      ensure
-        $stderr = orig
-      end
+      capture_stderr(&)
     end
-    result
+  end
+
+  def capture_stdout
+    orig = $stdout
+    $stdout = StringIO.new
+    yield
+    $stdout.string
+  ensure
+    $stdout = orig
+  end
+
+  def capture_stderr
+    orig = $stderr
+    $stderr = StringIO.new
+    yield
+    $stderr.string
+  ensure
+    $stderr = orig
   end
 
   def runner
@@ -66,17 +68,13 @@ RSpec.configure do |config|
 
     out[:STDERR] = capture(:STDERR) do
       out[:STDOUT] = capture(:STDOUT) do
-        begin
-          yield
-
-        rescue SystemExit
-          out[:aborted] = true
-
-        # rubocop:disable Lint/RescueException
-        rescue Exception => e
-          # rubocop:enable Lint/RescueException
-          out[:unexpected] = e
-        end
+        yield
+      rescue SystemExit
+        out[:aborted] = true
+      # rubocop:disable Lint/RescueException
+      rescue Exception => e
+        # rubocop:enable Lint/RescueException
+        out[:unexpected] = e
       end
     end
     out # return the output
@@ -93,17 +91,29 @@ RSpec.configure do |config|
     expect(actual[:STDERR]).to eq(desired[:STDERR])
   end
 
-  def clobber_db_files
+  def spec_root
+    File.dirname(__FILE__)
+  end
+end
+
+module SpecDatabaseHelpers
+  def self.clobber_db_files
     FileUtils.mkdir_p('tmp')
     paths = []
     Find.find('tmp') { |path| paths << path if path =~ /.*\.db$/ }
     paths.each { |file| File.delete(file) }
   end
+end
 
-  def spec_root
-    File.dirname(__FILE__)
-  end
+RSpec.configure do |config|
+  config.include CliHarness
+  config.include SpecOutputHelpers
+  # config.filter_run focus: true # <- enable to allow test focus
+  config.color = true
+  config.tty = true
+  config.formatter = :progress # :documentation # :progress, :html, :textmate
 
-  # Always start with a fresh db file.
-  clobber_db_files
+  config.before(:suite) do
+    SpecDatabaseHelpers.clobber_db_files
+  end
 end

data/spec/support/cli_harness.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module CliHarness
+  def setup_cli_harness(command_class:, command_ivar: nil, include_cli: false, extra_commands: {}, extra_args: [])
+    @mockarg_parts = {
+      config: File.join(spec_root, 'config/config.yml'),
+      format: 'yaml',
+      env: 'test'
+    }
+    @mockargs = build_cli_args(@mockarg_parts) + extra_args
+
+    @config = Moose::Inventory::Config
+    @config.init(@mockargs)
+
+    @console = Moose::Inventory::Cli::Formatter
+    @db = Moose::Inventory::DB
+    @db.init if @db.db.nil?
+
+    @app = Moose::Inventory::Cli::Application
+    @cli = Moose::Inventory::Cli if include_cli
+    instance_variable_set(command_ivar, command_class) unless command_ivar.nil?
+    extra_commands.each { |ivar, klass| instance_variable_set(ivar, klass) }
+  end
+
+  def reset_cli_harness(reset_config: false)
+    @config.init(@mockargs) if reset_config
+    @db.reset
+  end
+
+  def build_cli_args(parts)
+    parts.flat_map { |key, value| ["--#{key}", value] }
+  end
+end