moose-inventory 1.0.9 → 2.1

data/spec/lib/moose_inventory/db/exceptions_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Moose::Inventory::DB::MooseDBException do
+  it 'uses the provided exception message through RuntimeError' do
+    error = described_class.new('boom')
+
+    expect(error.message).to eq('boom')
+    expect(error.full_message).to include('boom')
+  end
+
+  it 'falls back to a default exception message' do
+    error = described_class.new
+
+    expect(error.message).to eq('An undefined Moose exception occurred')
+  end
+end

data/spec/lib/moose_inventory/db/models_spec.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
+# rubocop:disable Metrics/BlockLength
 RSpec.describe 'models' do
   #=============================
   # Initialization
@@ -8,9 +11,9 @@ RSpec.describe 'models' 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 = []
@@ -173,3 +176,4 @@ RSpec.describe 'models' do
     end
   end
 end
+# rubocop:enable Metrics/BlockLength

data/spec/lib/moose_inventory/db_lifecycle_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/BlockLength
+require 'spec_helper'
+require 'tmpdir'
+
+RSpec.describe 'database lifecycle commands' do
+  before(:all) do
+    setup_cli_harness(command_class: Moose::Inventory::Cli::Application)
+  end
+
+  before(:each) do
+    reset_cli_harness
+  end
+
+  it 'records the current schema version during database initialization' do
+    expect(Moose::Inventory::DB.schema_version).to eq(Moose::Inventory::DB::SCHEMA_VERSION)
+    expect(Moose::Inventory::DB.status[:tables][:schema_info]).to eq(true)
+  end
+
+  it 'prints database status' do
+    actual = runner { @app.start(%w[db status]) }
+
+    expect(actual[:unexpected]).to eq(false)
+    expect(actual[:aborted]).to eq(false)
+    expect(actual[:STDOUT]).to include('Adapter: sqlite3')
+    expect(actual[:STDOUT]).to include("Expected schema version: #{Moose::Inventory::DB::SCHEMA_VERSION}")
+    expect(actual[:STDOUT]).to include('- schema_info: present')
+  end
+
+  it 'runs db doctor successfully when schema state is current' do
+    actual = runner { @app.start(%w[db doctor]) }
+
+    expected(actual, aborted: false, STDOUT: "Database doctor found no issues.\n", STDERR: '')
+  end
+
+  it 'reports dirty partial schema state through db doctor' do
+    Moose::Inventory::DB.db.drop_table(:audit_events)
+
+    actual = runner { @app.start(%w[db doctor]) }
+
+    expect(actual[:unexpected]).to eq(false)
+    expect(actual[:aborted]).to eq(true)
+    expect(actual[:STDOUT]).to include('Database doctor found issue(s):')
+    expect(actual[:STDOUT]).to include('- Missing tables: audit_events')
+  end
+
+  it 'migrates missing lifecycle metadata' do
+    Moose::Inventory::DB.db.drop_table(:schema_info)
+
+    actual = runner { @app.start(%w[db migrate]) }
+
+    expect(actual[:unexpected]).to eq(false)
+    expect(actual[:aborted]).to eq(false)
+    expect(actual[:STDOUT]).to include("Database schema is at version #{Moose::Inventory::DB::SCHEMA_VERSION}.")
+    expect(Moose::Inventory::DB.schema_version).to eq(Moose::Inventory::DB::SCHEMA_VERSION)
+  end
+
+  it 'backs up the sqlite database file' do
+    Dir.mktmpdir do |dir|
+      destination = File.join(dir, 'backup.sqlite3')
+
+      actual = runner { @app.start(['db', 'backup', destination]) }
+
+      expect(actual[:unexpected]).to eq(false)
+      expect(actual[:aborted]).to eq(false)
+      expect(actual[:STDOUT]).to include("Backed up database to #{destination}.")
+      expect(File).to exist(destination)
+      expect(File.size(destination)).to be_positive
+    end
+  end
+end
+# rubocop:enable Metrics/BlockLength

data/spec/lib/moose_inventory/inventory_context_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'inventory_context'
+
+RSpec.describe Moose::Inventory::InventoryContext do
+  it 'requires an explicit db dependency' do
+    expect { described_class.new }.to raise_error(ArgumentError)
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'inventory_context'
+require 'operations/add_associations'
+
+RSpec.describe Moose::Inventory::Operations::AddAssociations 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 'adds groups to an existing host and reports creation/duplicate events' do
+    host = @db.models[:host].create(name: 'host1')
+    ungrouped = @db.models[:group].find_or_create(name: 'ungrouped')
+    host.add_group(ungrouped)
+    existing_group = @db.models[:group].create(name: 'existing')
+    host.add_group(existing_group)
+
+    result = operation.host_to_groups(
+      host: host,
+      host_name: 'host1',
+      group_names: %w[existing created]
+    )
+
+    expect(result.warning_count).to eq(2)
+    expect(result.events.map(&:type)).to include(
+      :host_group_association_exists,
+      :group_missing_created,
+      :removing_automatic_group
+    )
+    expect(host.groups_dataset[name: 'created']).not_to be_nil
+    expect(host.groups_dataset[name: 'ungrouped']).to be_nil
+  end
+
+  it 'dry-runs adding groups to a host without creating groups or changing automatic membership' do
+    host = @db.models[:host].create(name: 'host1')
+    ungrouped = @db.models[:group].find_or_create(name: 'ungrouped')
+    host.add_group(ungrouped)
+
+    result = operation.host_to_groups(
+      host: host,
+      host_name: 'host1',
+      group_names: ['created'],
+      dry_run: true
+    )
+
+    expect(result.warning_count).to eq(1)
+    expect(result.events.map(&:type)).to include(:group_missing_created, :removing_automatic_group, :dry_run_summary)
+    expect(@db.models[:group].find(name: 'created')).to be_nil
+    expect(host.groups_dataset[name: 'created']).to be_nil
+    expect(host.groups_dataset[name: 'ungrouped']).not_to be_nil
+  end
+
+  it 'dry-runs adding hosts to a group without creating hosts or changing automatic membership' do
+    group = @db.models[:group].create(name: 'group1')
+
+    result = operation.group_to_hosts(
+      group: group,
+      group_name: 'group1',
+      host_names: ['host1'],
+      dry_run: true
+    )
+
+    expect(result.warning_count).to eq(1)
+    expect(result.events.map(&:type)).to include(:host_missing_created, :dry_run_summary)
+    expect(@db.models[:host].find(name: 'host1')).to be_nil
+    expect(group.hosts_dataset[name: 'host1']).to be_nil
+  end
+  it 'adds hosts to an existing group and reports creation/duplicate events' do
+    group = @db.models[:group].create(name: 'group1')
+    duplicate_host = @db.models[:host].create(name: 'host1')
+    existing_host = @db.models[:host].create(name: 'host3')
+    ungrouped = @db.models[:group].find_or_create(name: 'ungrouped')
+    duplicate_host.add_group(ungrouped)
+    existing_host.add_group(ungrouped)
+    group.add_host(duplicate_host)
+
+    result = operation.group_to_hosts(
+      group: group,
+      group_name: 'group1',
+      host_names: %w[host1 host2 host3]
+    )
+
+    expect(result.warning_count).to eq(2)
+    expect(result.events.map(&:type)).to include(
+      :group_host_association_exists,
+      :host_missing_created,
+      :removing_automatic_group
+    )
+    expect(group.hosts_dataset[name: 'host2']).not_to be_nil
+    expect(existing_host.groups_dataset[name: 'ungrouped']).to be_nil
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'inventory_context'
+require 'operations/add_groups'
+
+RSpec.describe Moose::Inventory::Operations::AddGroups 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 'adds a group and returns structured events without rendering output' do
+    actual = runner do
+      @result = operation.call(names: ['testgroup'], hosts: [])
+    end
+
+    expected(actual, STDOUT: '', STDERR: '')
+    expect(@result.warning_count).to eq(0)
+    expect(@result.events.map(&:type)).to eq(%i[group_started creating_group ok group_complete])
+
+    group = @db.models[:group].find(name: 'testgroup')
+    expect(group).not_to be_nil
+  end
+
+  it 'returns dry-run events without creating groups, hosts, or associations' do
+    result = operation.call(
+      names: ['testgroup'],
+      hosts: ['missinghost'],
+      dry_run: true
+    )
+
+    expect(result.warning_count).to eq(1)
+    expect(result.events.map(&:type)).to eq(
+      %i[group_started creating_group ok adding_association host_missing_created host_creating_now ok ok group_complete
+         dry_run_summary]
+    )
+    expect(@db.models[:group].find(name: 'testgroup')).to be_nil
+    expect(@db.models[:host].find(name: 'missinghost')).to be_nil
+  end
+  it 'reports existing groups, created hosts, duplicate associations, and ungrouped removal as events' do
+    host = @db.models[:host].create(name: 'testhost')
+    ungrouped = @db.models[:group].find_or_create(name: 'ungrouped')
+    host.add_group(ungrouped)
+    group = @db.models[:group].create(name: 'testgroup')
+    group.add_host(host)
+
+    @result = operation.call(
+      names: ['testgroup'],
+      hosts: %w[testhost newhost]
+    )
+
+    expect(@result.warning_count).to eq(3)
+    expect(@result.events.map(&:type)).to include(
+      :group_exists,
+      :association_exists,
+      :host_missing_created,
+      :removing_automatic_group
+    )
+    expect(@db.models[:host].find(name: 'newhost')).not_to be_nil
+    expect(host.groups_dataset[name: 'ungrouped']).to be_nil
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Moose::Inventory::Operations::AddHosts 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
+
+  describe '#call' do
+    it 'adds a host and returns structured events without rendering output' do
+      actual = runner do
+        @result = operation.call(names: ['testhost'], groups: [])
+      end
+
+      expected(actual, STDOUT: '', STDERR: '')
+      expect(@result.events.map(&:type)).to eq(
+        %i[host_started creating_host ok adding_automatic_group ok host_complete]
+      )
+      expect(@result.events[0].payload).to eq(name: 'testhost')
+      expect(@result.events[3].payload).to eq(host: 'testhost', group: 'ungrouped')
+
+      host = @db.models[:host].find(name: 'testhost')
+      expect(host).not_to be_nil
+      expect(host.groups_dataset[name: 'ungrouped']).not_to be_nil
+    end
+
+    it 'returns dry-run events without creating hosts, groups, or associations' do
+      @result = operation.call(
+        names: ['testhost'],
+        groups: ['missinggroup'],
+        dry_run: true
+      )
+
+      expect(@result.events.map(&:type)).to eq(
+        %i[host_started creating_host ok adding_association group_missing_created ok host_complete dry_run_summary]
+      )
+      expect(@db.models[:host].find(name: 'testhost')).to be_nil
+      expect(@db.models[:group].find(name: 'missinggroup')).to be_nil
+    end
+    it 'reports existing hosts, missing groups, and duplicate associations as events' do
+      host = @db.models[:host].create(name: 'testhost')
+      group = @db.models[:group].create(name: 'existinggroup')
+      host.add_group(group)
+
+      @result = operation.call(
+        names: ['testhost'],
+        groups: %w[existinggroup missinggroup]
+      )
+
+      expect(@result.events.map(&:type)).to include(
+        :host_exists,
+        :association_exists,
+        :group_missing_created
+      )
+      expect(@result.events.find { |event| event.type == :host_exists }.payload).to eq(name: 'testhost')
+      expect(@result.events.find { |event| event.type == :association_exists }.payload).to eq(
+        host: 'testhost',
+        group: 'existinggroup'
+      )
+      expect(@db.models[:group].find(name: 'missinggroup')).not_to be_nil
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'inventory_context'
+require 'operations/add_variables'
+
+RSpec.describe Moose::Inventory::Operations::AddVariables 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 'adds host variables and returns structured events without rendering output' do
+    @db.models[:host].create(name: 'test1')
+
+    actual = runner do
+      @result = build_operation(:host).call(name: 'test1', vars: ['var1=val1'])
+    end
+
+    expected(actual, STDOUT: '', STDERR: '')
+    expect(@result.events.map(&:type)).to eq(
+      %i[entity_started retrieving_entity ok adding_variable ok entity_complete]
+    )
+
+    host = @db.models[:host].find(name: 'test1')
+    expect(host.hostvars_dataset[name: 'var1'][:value]).to eq('val1')
+  end
+
+  it 'updates an existing group variable and emits an update event' do
+    group = @db.models[:group].create(name: 'testgroup')
+    var = @db.models[:groupvar].create(name: 'var1', value: 'old')
+    group.add_groupvar(var)
+
+    result = build_operation(:group).call(name: 'testgroup', vars: ['var1=new'])
+
+    expect(result.events.map(&:type)).to include(:updating_existing_variable)
+    expect(group.groupvars_dataset[name: 'var1'][:value]).to eq('new')
+    expect(@db.models[:groupvar].count).to eq(1)
+  end
+
+  it 'dry-runs adding and updating variables without writing records' do
+    host = @db.models[:host].create(name: 'test1')
+    existing = @db.models[:hostvar].create(name: 'var1', value: 'old')
+    host.add_hostvar(existing)
+
+    result = build_operation(:host).call(
+      name: 'test1',
+      vars: %w[var1=new var2=val2],
+      dry_run: true
+    )
+
+    expect(result.events.map(&:type)).to include(:updating_existing_variable, :dry_run_summary)
+    expect(host.hostvars_dataset[name: 'var1'][:value]).to eq('old')
+    expect(host.hostvars_dataset[name: 'var2']).to be_nil
+  end
+
+  it 'uses the shared variable operation support for missing entity errors' do
+    operation = build_operation(:host)
+
+    expect do
+      operation.call(name: 'ghost', vars: ['var1=val1'])
+    end.to raise_error(Moose::Inventory::DB.exceptions[:moose], "The host 'ghost' does not exist.")
+  end
+
+  it 'rejects unsupported entity types via the shared variable operation support' do
+    operation = build_operation(:thing)
+
+    expect do
+      operation.call(name: 'whatever', vars: ['var1=val1'])
+    end.to raise_error(ArgumentError, /Unsupported entity type/)
+  end
+
+  it 'emits partial progress before raising on malformed host variable input' do
+    @db.models[:host].create(name: 'test1')
+    emitted = []
+    operation = build_operation(:host, emitter: emitted.method(:<<))
+
+    expect do
+      operation.call(name: 'test1', vars: ['broken'])
+    end.to raise_error(Moose::Inventory::DB.exceptions[:moose], /Expected 'key=value'/)
+
+    expect(emitted.map(&:type)).to eq(%i[entity_started retrieving_entity ok adding_variable])
+  end
+end

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'inventory_context'
+require 'operations/group_child_relations'
+
+RSpec.describe Moose::Inventory::Operations::GroupChildRelations 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 'adds child groups and reports duplicate and auto-create events' do
+    parent = @db.models[:group].create(name: 'parent')
+    existing = @db.models[:group].create(name: 'existing')
+    parent.add_child(existing)
+
+    result = operation.add_children(
+      parent_group: parent,
+      parent_name: 'parent',
+      child_names: %w[existing created]
+    )
+
+    expect(result.warning_count).to eq(2)
+    expect(result.events.map(&:type)).to include(
+      :child_association_exists,
+      :child_group_missing
+    )
+    expect(parent.children_dataset[name: 'created']).not_to be_nil
+  end
+
+  it 'dry-runs adding child groups without creating children or associations' do
+    parent = @db.models[:group].create(name: 'parent')
+
+    result = operation.add_children(
+      parent_group: parent,
+      parent_name: 'parent',
+      child_names: ['created'],
+      dry_run: true
+    )
+
+    expect(result.warning_count).to eq(1)
+    expect(result.events.map(&:type)).to include(:child_group_missing, :dry_run_summary)
+    expect(@db.models[:group].find(name: 'created')).to be_nil
+    expect(parent.children_dataset[name: 'created']).to be_nil
+  end
+
+  it 'dry-runs removing child groups without deleting orphaned descendants' do
+    parent = @db.models[:group].create(name: 'parent')
+    child = @db.models[:group].create(name: 'child')
+    grandchild = @db.models[:group].create(name: 'grandchild')
+    host = @db.models[:host].create(name: 'child-host')
+    child.add_host(host)
+    parent.add_child(child)
+    child.add_child(grandchild)
+
+    result = operation.remove_children(
+      parent_group: parent,
+      parent_name: 'parent',
+      child_names: ['child'],
+      delete_orphans: true,
+      dry_run: true
+    )
+
+    expect(result.warning_count).to eq(0)
+    expect(result.events.map(&:type)).to include(
+      :recursively_delete_orphaned_group,
+      :destroying_group,
+      :adding_automatic_group_to_host,
+      :dry_run_summary
+    )
+    expect(parent.children_dataset[name: 'child']).not_to be_nil
+    expect(@db.models[:group].find(name: 'child')).not_to be_nil
+    expect(@db.models[:group].find(name: 'grandchild')).not_to be_nil
+    expect(host.groups_dataset[name: 'ungrouped']).to be_nil
+  end
+
+  it 'removes child groups and recursively deletes orphan groups when requested' do
+    parent = @db.models[:group].create(name: 'parent')
+    child = @db.models[:group].create(name: 'child')
+    grandchild = @db.models[:group].create(name: 'grandchild')
+    host = @db.models[:host].create(name: 'child-host')
+    child.add_host(host)
+    parent.add_child(child)
+    child.add_child(grandchild)
+
+    result = operation.remove_children(
+      parent_group: parent,
+      parent_name: 'parent',
+      child_names: %w[missing child],
+      delete_orphans: true
+    )
+
+    expect(result.warning_count).to eq(1)
+    expect(result.events.map(&:type)).to include(
+      :child_association_missing,
+      :recursively_delete_orphaned_group,
+      :destroying_group,
+      :adding_automatic_group_to_host
+    )
+    expect(@db.models[:group].find(name: 'child')).to be_nil
+    expect(@db.models[:group].find(name: 'grandchild')).to be_nil
+    expect(host.groups_dataset[name: 'ungrouped']).not_to be_nil
+  end
+end