moose-inventory 2.0 → 2.1

data/spec/lib/moose_inventory/ansible_plugin_examples_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'yaml'
+
+RSpec.describe 'Ansible inventory plugin examples' do
+  it 'ships a plugin, inventory source, and ansible.cfg example' do
+    expect(File).to exist('examples/ansible/inventory_plugins/moose_inventory.py')
+    expect(File).to exist('examples/ansible/inventory/moose_inventory.yml')
+    expect(File).to exist('examples/ansible/ansible.cfg')
+  end
+
+  it 'uses the moose_inventory plugin in the example inventory source' do
+    config = YAML.safe_load_file('examples/ansible/inventory/moose_inventory.yml')
+
+    expect(config).to include(
+      'plugin' => 'moose_inventory',
+      'executable' => 'moose-inventory',
+      'config' => './example.conf',
+      'env' => 'dev'
+    )
+  end
+
+  it 'keeps the plugin source syntax-valid' do
+    result = system('python3', '-m', 'py_compile', 'examples/ansible/inventory_plugins/moose_inventory.py')
+
+    expect(result).to eq(true)
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/BlockLength
+require 'spec_helper'
+
+RSpec.describe Moose::Inventory::Cli::Application do
+  before(:all) do
+    setup_cli_harness(command_class: described_class)
+  end
+
+  before(:each) do
+    reset_cli_harness
+  end
+
+  it 'prints a human success report when no issues are found' do
+    web = @db.models[:group].create(name: 'web')
+    host = @db.models[:host].create(name: 'web01')
+    host.add_group(web)
+
+    actual = runner { @app.start(%w[doctor]) }
+
+    expected(actual, aborted: false, STDOUT: "Inventory doctor found no issues.\n", STDERR: '')
+  end
+
+  it 'prints a human report and exits nonzero when issues are found' do
+    @db.models[:group].create(name: 'ungrouped')
+    host = @db.models[:host].create(name: 'lonely')
+    host.add_group(@db.models[:group].find(name: 'ungrouped'))
+
+    actual = runner { @app.start(%w[doctor]) }
+
+    expect(actual[:aborted]).to eq(true)
+    expect(actual[:STDOUT]).to include('Inventory doctor found')
+    expect(actual[:STDOUT]).to include('host_only_in_ungrouped')
+  end
+
+  it 'prints a machine-readable report when requested' do
+    @db.models[:group].create(name: 'ungrouped')
+    host = @db.models[:host].create(name: 'lonely')
+    host.add_group(@db.models[:group].find(name: 'ungrouped'))
+
+    actual = runner { @app.start(%w[doctor --format json]) }
+
+    expect(actual[:aborted]).to eq(true)
+    report = JSON.parse(actual[:STDOUT])
+    expect(report['ok']).to eq(false)
+    expect(report['issues'].map { |issue| issue['id'] }).to include('host_only_in_ungrouped')
+  end
+end
+# rubocop:enable Metrics/BlockLength

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/BlockLength
+require 'spec_helper'
+require 'tmpdir'
+
+RSpec.describe Moose::Inventory::Cli::Application do
+  before(:all) do
+    setup_cli_harness(command_class: described_class)
+  end
+
+  before(:each) do
+    reset_cli_harness
+  end
+
+  it 'exports the current inventory snapshot as yaml' do
+    runner { @app.start(%w[host add web01]) }
+    runner { @app.start(%w[group add web]) }
+    runner { @app.start(%w[host addgroup web01 web]) }
+
+    actual = runner { @app.start(%w[export]) }
+
+    expect(actual[:unexpected]).to eq(false)
+    expect(actual[:aborted]).to eq(false)
+    expect(actual[:STDERR]).to eq('')
+    snapshot = YAML.safe_load(actual[:STDOUT])
+    expect(snapshot['version']).to eq(1)
+    expect(snapshot.dig('hosts', 'web01', 'groups')).to include('web')
+    expect(snapshot['groups']).to have_key('web')
+  end
+
+  it 'imports a validated inventory snapshot file' do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, 'inventory.yml')
+      File.write(
+        path,
+        {
+          'version' => 1,
+          'hosts' => { 'web01' => { 'groups' => ['web'], 'tags' => [], 'vars' => { 'env' => 'prod' } } },
+          'groups' => { 'web' => { 'children' => [], 'tags' => [], 'vars' => { 'role' => 'frontend' } } }
+        }.to_yaml
+      )
+
+      actual = runner { @app.start(['import', path]) }
+
+      expect(actual[:unexpected]).to eq(false)
+      expect(actual[:aborted]).to eq(false)
+      expect(actual[:STDERR]).to eq('')
+      expect(actual[:STDOUT]).to include("Imported inventory snapshot from #{path}.")
+      host = @db.models[:host].find(name: 'web01')
+      expect(host.groups_dataset[name: 'web']).not_to be_nil
+      expect(host.hostvars_dataset[name: 'env'][:value]).to eq('prod')
+    end
+  end
+
+  it 'previews an inventory snapshot import without writing' do
+    runner { @app.start(%w[group add web]) }
+
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, 'inventory.yml')
+      File.write(
+        path,
+        {
+          'version' => 1,
+          'hosts' => { 'web01' => { 'groups' => ['web'], 'tags' => [], 'vars' => { 'env' => 'prod' } } },
+          'groups' => { 'web' => { 'children' => [], 'tags' => [], 'vars' => {} } }
+        }.to_yaml
+      )
+
+      actual = runner { @app.start(['import', path, '--preview', '--preview-format', 'json']) }
+
+      expect(actual[:unexpected]).to eq(false)
+      expect(actual[:aborted]).to eq(false)
+      expect(actual[:STDERR]).to eq('')
+      preview = JSON.parse(actual[:STDOUT])
+      expect(preview['schema_version']).to eq('snapshot-import-preview-v1')
+      expect(preview['changes_applied']).to eq(false)
+      expect(preview.dig('summary', 'hosts_created')).to eq(1)
+      expect(preview.dig('creates', 'hosts')).to eq(['web01'])
+      expect(@db.models[:host].find(name: 'web01')).to be_nil
+    end
+  end
+
+  it 'aborts on invalid snapshot input without writing' do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, 'inventory.yml')
+      File.write(
+        path,
+        { 'version' => 1, 'hosts' => { 'web01' => { 'groups' => ['missing'], 'vars' => {} } }, 'groups' => {} }.to_yaml
+      )
+
+      actual = runner { @app.start(['import', path]) }
+
+      expect(actual[:aborted]).to eq(true)
+      expect(actual[:STDERR]).to include("Invalid inventory snapshot: host 'web01' references unknown group 'missing'.")
+      expect(@db.models[:host].count).to eq(0)
+    end
+  end
+end
+# rubocop:enable Metrics/BlockLength

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

@@ -1,15 +1,25 @@
-# require 'spec_helper'
-#
-# RSpec.describe Moose::Inventory::Cli::Group do
-#  before do
-#    # Set up the configuration object
-#    mockargs = "--format yaml --env testing --config ./test.config"
-#    Moose::Inventory::Config
-#  end
-#
-#  describe ".add" do
-#    it '"add test" should add a group called test' do
-#      expect(["group","add","test").to_eq(2)
-#    end
-#  end
-# end
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Moose::Inventory::Cli::Application do
+  describe 'version' do
+    it 'prints the current Moose Inventory version' do
+      output = capture(:STDOUT) do
+        described_class.start(%w[version])
+      end
+
+      expect(output).to eq("Version #{Moose::Inventory::VERSION}\n")
+    end
+  end
+
+  describe 'subcommands' do
+    it 'registers the group subcommand' do
+      expect(described_class.subcommands).to include('group')
+    end
+
+    it 'registers the host subcommand' do
+      expect(described_class.subcommands).to include('host')
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'spec_helper'
+
+# rubocop:disable Metrics/BlockLength
+RSpec.describe Moose::Inventory::Cli::Audit do
+  before(:all) do
+    setup_cli_harness(command_class: Moose::Inventory::Cli::Audit)
+  end
+
+  before(:each) do
+    reset_cli_harness
+  end
+
+  it 'starts with an empty audit log' do
+    actual = runner { @app.start(%w[audit list]) }
+
+    expected(actual, aborted: false, STDOUT: "No audit events recorded.\n", STDERR: '')
+  end
+
+  it 'records successful mutating host commands' do
+    add = runner { @app.start(%w[host add app01]) }
+    expect(add[:unexpected]).to eq(false)
+
+    event = @db.models[:audit_event].last
+    expect(event.command).to eq('host add')
+    expect(event.action).to eq('add')
+    expect(event.entity_type).to eq('host')
+    expect(event.entity_name).to eq('app01')
+    expect(JSON.parse(event.details)).to include('events')
+  end
+
+  it 'does not record dry-run commands' do
+    actual = runner { @app.start(%w[host add --dry-run app01]) }
+    expect(actual[:unexpected]).to eq(false)
+
+    expect(@db.models[:audit_event].count).to eq(0)
+  end
+
+  it 'lists audit events as machine-readable JSON' do
+    runner { @app.start(%w[group add web]) }
+
+    actual = runner { @app.start(%w[audit list --format json]) }
+    parsed = JSON.parse(actual[:STDOUT])
+
+    expect(actual[:unexpected]).to eq(false)
+    expect(parsed.first).to include(
+      'command' => 'group add',
+      'action' => 'add',
+      'entity_type' => 'group',
+      'entity_name' => 'web'
+    )
+  end
+end
+# rubocop:enable Metrics/BlockLength

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

@@ -1,25 +1,21 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-RSpec.describe Moose::Inventory::Cli::Application do
-  before do
-    @app = Moose::Inventory::Cli::Application
-  end
+RSpec.describe Moose::Inventory::Cli do
+  describe '.start' do
+    it 'wires config, db, and application explicitly' do
+      args = ['--format', 'yaml']
+      config = instance_double('Config')
+      db = instance_double('DB')
+      application = class_double('Application')
 
-  describe '.version' do
-    # --------------------
-    it 'method should be responsive' do
-      result = @app.instance_methods(false).include?(:version)
-      expect(result).to eq(true)
-    end
+      expect(config).to receive(:init).with(args).ordered
+      expect(db).to receive(:init).ordered
+      expect(config).to receive(:application_args).ordered.and_return(['version'])
+      expect(application).to receive(:start).with(['version']).ordered
 
-    # --------------------
-    #    it 'should output version information' do
-    #      actual = runner { @app.version }
-    #
-    #      desired = {}
-    #      desired[:STDERR] = "Version #{Moose::Inventory::VERSION}"
-    #
-    #      expected(actual, desired)
-    #    end
+      described_class.start(args, config: config, db: db, application: application)
+    end
   end
 end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'stringio'
+
+# rubocop:disable Metrics/BlockLength
+RSpec.describe Moose::Inventory::Cli::Console do
+  before(:all) do
+    setup_cli_harness(command_class: Moose::Inventory::Cli::Application)
+  end
+
+  before(:each) do
+    reset_cli_harness
+  end
+
+  def run_console(input)
+    original_stdin = $stdin
+    $stdin = StringIO.new(input)
+    runner { @app.start(%w[console]) }
+  ensure
+    $stdin = original_stdin
+  end
+
+  it 'prints help and exits' do
+    actual = run_console("help\nquit\n")
+
+    expect(actual[:unexpected]).to eq(false)
+    expect(actual[:STDOUT]).to include('Moose Inventory console (read-only). Type help or quit.')
+    expect(actual[:STDOUT]).to include('- hosts')
+    expect(actual[:STDOUT]).to include('- group NAME')
+    expect(actual[:STDOUT]).to include('Goodbye.')
+  end
+
+  it 'browses hosts, groups, tags, and entity detail without mutating' do
+    runner { @app.start(%w[group add web]) }
+    runner { @app.start(%w[host add web01 --groups web]) }
+    runner { @app.start(%w[host addtag web01 prod]) }
+    before_audit_count = @db.models[:audit_event].count
+
+    actual = run_console("hosts\ngroups\nhost web01\ntags host web01\nquit\n")
+
+    expect(actual[:unexpected]).to eq(false)
+    expect(actual[:STDOUT]).to include('Hosts: web01')
+    expect(actual[:STDOUT]).to include('Groups: web')
+    expect(actual[:STDOUT]).to include('Host: web01')
+    expect(actual[:STDOUT]).to include('Tags: prod')
+    expect(@db.models[:audit_event].count).to eq(before_audit_count)
+  end
+
+  it 'reports unknown and missing entities safely' do
+    actual = run_console("nonsense\nhost missing\nquit\n")
+
+    expect(actual[:unexpected]).to eq(false)
+    expect(actual[:STDOUT]).to include('Unknown command: nonsense')
+    expect(actual[:STDOUT]).to include("Host 'missing' not found.")
+  end
+
+  it 'supports quoted read-only entity names' do
+    group = @db.models[:group].create(name: 'prod group')
+    host = @db.models[:host].create(name: 'web 01')
+    tag = @db.models[:tag].create(name: 'critical host')
+    host.add_group(group)
+    host.add_tag(tag)
+    before_audit_count = @db.models[:audit_event].count
+
+    actual = run_console("host \"web 01\"\ntags host \"web 01\"\ngroup 'prod group'\nquit\n")
+
+    expect(actual[:unexpected]).to eq(false)
+    expect(actual[:STDOUT]).to include('Host: web 01')
+    expect(actual[:STDOUT]).to include('Groups: prod group')
+    expect(actual[:STDOUT]).to include('critical host')
+    expect(actual[:STDOUT]).to include('Group: prod group')
+    expect(actual[:STDOUT]).to include('Hosts: web 01')
+    expect(@db.models[:audit_event].count).to eq(before_audit_count)
+  end
+
+  it 'reports command-specific usage for extra or invalid arguments' do
+    actual = run_console("host one two\ntags host\naudit nope\naudit 0\nhelp extra\nquit\n")
+
+    expect(actual[:unexpected]).to eq(false)
+    expect(actual[:STDOUT]).to include('Usage: host NAME')
+    expect(actual[:STDOUT]).to include('Usage: tags host|group NAME')
+    expect(actual[:STDOUT].scan('Usage: audit [LIMIT]').length).to eq(2)
+    expect(actual[:STDOUT]).to include('Usage: help')
+  end
+
+  it 'reports unclosed quoted input without leaving read-only mode' do
+    before_audit_count = @db.models[:audit_event].count
+
+    actual = run_console("host \"unterminated\nquit\n")
+
+    expect(actual[:unexpected]).to eq(false)
+    expect(actual[:STDOUT]).to include('Invalid command syntax:')
+    expect(actual[:STDOUT]).to include('Goodbye.')
+    expect(@db.models[:audit_event].count).to eq(before_audit_count)
+  end
+end
+# rubocop:enable Metrics/BlockLength

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'cli/factory'
+require 'operations/query_inventory'
+
+RSpec.describe Moose::Inventory::Cli::Factory do
+  let(:context) { instance_double('InventoryContext') }
+  subject(:factory) { described_class.new(context: context) }
+
+  it 'builds operations with the shared context' do
+    operation_class = class_double('OperationClass')
+    operation = instance_double('Operation')
+
+    expect(operation_class).to receive(:new).with(context: context, emitter: :emit).and_return(operation)
+
+    expect(factory.operation(operation_class, emitter: :emit)).to eq(operation)
+  end
+
+  it 'memoizes the query inventory wrapper for the shared context' do
+    first = factory.query_inventory
+    second = factory.query_inventory
+
+    expect(first).to be_a(Moose::Inventory::Operations::QueryInventory)
+    expect(second).to equal(first)
+  end
+end

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

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 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::Formatter do
@@ -33,7 +34,7 @@ RSpec.describe Moose::Inventory::Cli::Formatter do
       actual = runner { @formatter.out(test, 'json') }
 
       desired = { aborted: false, STDOUT: '', STDERR: '' }
-      desired[:STDOUT] = test.to_json + "\n"
+      desired[:STDOUT] = "#{test.to_json}\n"
 
       expected(actual, desired)
     end
@@ -44,7 +45,7 @@ RSpec.describe Moose::Inventory::Cli::Formatter do
       actual = runner { @formatter.out(test, 'prettyjson') }
 
       desired = { aborted: false, STDOUT: '', STDERR: '' }
-      desired[:STDOUT] = JSON.pretty_generate(test) + "\n"
+      desired[:STDOUT] = "#{JSON.pretty_generate(test)}\n"
 
       expected(actual, desired)
     end
@@ -59,5 +60,96 @@ RSpec.describe Moose::Inventory::Cli::Formatter do
 
       expected(actual, desired)
     end
+
+    it 'info() prints the provided message instead of a literal placeholder' do
+      actual = runner { @formatter.info(2, 'hello world') }
+
+      desired = { aborted: false, STDOUT: '', STDERR: '' }
+      desired[:STDOUT] = '  INFO: hello world'
+
+      expected(actual, desired)
+    end
+  end
+
+  describe 'stream helpers' do
+    it 'puts() writes indented text to stdout by default' do
+      actual = runner { @formatter.puts(2, 'hello world') }
+
+      desired = { aborted: false, STDOUT: "  hello world\n", STDERR: '' }
+
+      expected(actual, desired)
+    end
+
+    it 'puts() writes indented text to stderr when requested' do
+      actual = runner { @formatter.puts(2, 'hello world', 'STDERR') }
+
+      desired = { aborted: false, STDOUT: '', STDERR: "  hello world\n" }
+
+      expected(actual, desired)
+    end
+
+    it 'puts() aborts on an unknown output stream' do
+      actual = runner { @formatter.puts(2, 'hello world', 'BOGUS') }
+
+      desired = { aborted: true, STDOUT: '', STDERR: "Output stream 'BOGUS' is not known.\n" }
+
+      expected(actual, desired)
+    end
+
+    it 'print() writes indented text to stdout by default' do
+      actual = runner { @formatter.print(2, 'hello world') }
+
+      desired = { aborted: false, STDOUT: '  hello world', STDERR: '' }
+
+      expected(actual, desired)
+    end
+
+    it 'print() writes indented text to stderr when requested' do
+      actual = runner { @formatter.print(2, 'hello world', 'STDERR') }
+
+      desired = { aborted: false, STDOUT: '', STDERR: '  hello world' }
+
+      expected(actual, desired)
+    end
+
+    it 'print() aborts on an unknown output stream' do
+      actual = runner { @formatter.print(2, 'hello world', 'BOGUS') }
+
+      desired = { aborted: true, STDOUT: '', STDERR: "Output stream 'BOGUS' is not known.\n" }
+
+      expected(actual, desired)
+    end
+
+    it 'info() writes to stderr when requested' do
+      actual = runner { @formatter.info(2, 'hello world', 'STDERR') }
+
+      desired = { aborted: false, STDOUT: '', STDERR: '  INFO: hello world' }
+
+      expected(actual, desired)
+    end
+
+    it 'info() aborts on an unknown output stream' do
+      actual = runner { @formatter.info(2, 'hello world', 'BOGUS') }
+
+      desired = { aborted: true, STDOUT: '', STDERR: "Output stream 'BOGUS' is not known.\n" }
+
+      expected(actual, desired)
+    end
+
+    it 'warn() writes to stderr with the warning prefix' do
+      actual = runner { @formatter.warn('hello world') }
+
+      desired = { aborted: false, STDOUT: '', STDERR: 'WARNING: hello world' }
+
+      expected(actual, desired)
+    end
+
+    it 'error() writes to stderr with the error prefix' do
+      actual = runner { @formatter.error('hello world') }
+
+      desired = { aborted: false, STDOUT: '', STDERR: 'ERROR: hello world' }
+
+      expected(actual, desired)
+    end
   end
 end