moose-inventory 1.0.9 → 2.1

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

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/BlockLength
+require 'spec_helper'
+require 'inventory_context'
+require 'operations/inventory_snapshot'
+require 'operations/import_inventory_snapshot'
+
+RSpec.describe Moose::Inventory::Operations::ImportInventorySnapshot 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 'imports a validated snapshot transactionally' do
+    snapshot = {
+      'version' => 1,
+      'hosts' => {
+        'web01' => { 'groups' => ['web'], 'tags' => [], 'vars' => { 'env' => 'prod' } }
+      },
+      'groups' => {
+        'web' => { 'children' => ['blue'], 'tags' => [], 'vars' => { 'role' => 'frontend' } },
+        'blue' => { 'children' => [], 'tags' => [], 'vars' => {} }
+      }
+    }
+
+    result = operation.call(snapshot: snapshot)
+
+    expect(result.created_hosts).to eq(1)
+    expect(result.created_groups).to eq(2)
+    expect(result.updated_variables).to eq(2)
+    expect(result.associations).to eq(2)
+    host = @db.models[:host].find(name: 'web01')
+    group = @db.models[:group].find(name: 'web')
+    expect(host.groups_dataset[name: 'web']).not_to be_nil
+    expect(host.hostvars_dataset[name: 'env'][:value]).to eq('prod')
+    expect(group.children_dataset[name: 'blue']).not_to be_nil
+    expect(group.groupvars_dataset[name: 'role'][:value]).to eq('frontend')
+  end
+
+  it 'normalizes imported tag casing and deduplicates tags before applying' do
+    snapshot = {
+      version: 1,
+      hosts: {
+        web01: { groups: ['web'], tags: ['Prod', 'prod', ' OWNER-Platform ', ''], vars: {} }
+      },
+      groups: {
+        web: { children: [], tags: %w[Frontend frontend], vars: {} }
+      }
+    }
+
+    result = operation.call(snapshot: snapshot)
+
+    host = @db.models[:host].find(name: 'web01')
+    group = @db.models[:group].find(name: 'web')
+    expect(result.associations).to eq(4)
+    expect(host.tags_dataset.order(:name).map(:name)).to eq(%w[owner-platform prod])
+    expect(group.tags_dataset.order(:name).map(:name)).to eq(%w[frontend])
+    expect(@db.models[:tag].order(:name).map(:name)).to eq(%w[frontend owner-platform prod])
+    expect(@db.models[:tag].where(name: 'Prod').count).to eq(0)
+
+    exported = Moose::Inventory::Operations::InventorySnapshot.new(
+      context: Moose::Inventory::InventoryContext.new(db: @db)
+    ).export
+    expect(exported.dig('hosts', 'web01', 'tags')).to eq(%w[owner-platform prod])
+    expect(exported.dig('groups', 'web', 'tags')).to eq(%w[frontend])
+  end
+
+  it 'rejects unknown group references before writing anything' do
+    snapshot = {
+      version: 1,
+      hosts: { web01: { groups: ['missing'], vars: {} } },
+      groups: {}
+    }
+
+    expect do
+      operation.call(snapshot: snapshot)
+    end.to raise_error(Moose::Inventory::DB.exceptions[:moose], /references unknown group 'missing'/)
+
+    expect(@db.models[:host].count).to eq(0)
+    expect(@db.models[:group].count).to eq(0)
+  end
+
+  it 'rejects whitespace-only entity names before writing anything' do
+    snapshot = {
+      version: 1,
+      hosts: { '   ' => { groups: [], vars: {} } },
+      groups: {}
+    }
+
+    expect do
+      operation.call(snapshot: snapshot)
+    end.to raise_error(Moose::Inventory::DB.exceptions[:moose], /host name cannot be empty/)
+
+    expect(@db.models[:host].count).to eq(0)
+  end
+
+  it 'rejects duplicate normalized keys before applying the snapshot' do
+    snapshot = {
+      'version' => 1,
+      :version => 1,
+      hosts: {},
+      groups: {}
+    }
+
+    expect do
+      operation.call(snapshot: snapshot)
+    end.to raise_error(Moose::Inventory::DB.exceptions[:moose], /duplicate normalized key 'version'/)
+
+    expect(@db.models[:host].count).to eq(0)
+    expect(@db.models[:group].count).to eq(0)
+  end
+
+  it 'rejects whitespace-only variable names before writing anything' do
+    snapshot = {
+      version: 1,
+      hosts: { web01: { groups: [], vars: { '   ' => 'prod' } } },
+      groups: {}
+    }
+
+    expect do
+      operation.call(snapshot: snapshot)
+    end.to raise_error(Moose::Inventory::DB.exceptions[:moose], /variable name cannot be empty/)
+
+    expect(@db.models[:host].count).to eq(0)
+  end
+
+  it 'rejects circular group hierarchies before writing anything' do
+    snapshot = {
+      version: 1,
+      hosts: {},
+      groups: {
+        parent: { children: ['child'], vars: {} },
+        child: { children: ['parent'], vars: {} }
+      }
+    }
+
+    expect do
+      operation.call(snapshot: snapshot)
+    end.to raise_error(Moose::Inventory::DB.exceptions[:moose], /contains a cycle/)
+
+    expect(@db.models[:group].count).to eq(0)
+  end
+end
+# rubocop:enable Metrics/BlockLength
+
+# rubocop:disable Metrics/BlockLength
+
+RSpec.describe Moose::Inventory::Operations::ImportInventorySnapshot, '#preview' 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 'returns a non-mutating snapshot import diff' do
+    runner = operation
+    @db.models[:host].create(name: 'existing')
+    group = @db.models[:group].create(name: 'web')
+    var = @db.models[:groupvar].create(name: 'role', value: 'old')
+    group.add_groupvar(var)
+
+    snapshot = {
+      version: 1,
+      hosts: {
+        web01: { groups: ['web'], tags: ['Prod'], vars: { env: 'prod' } }
+      },
+      groups: {
+        web: { children: ['blue'], tags: ['Frontend'], vars: { role: 'frontend' } },
+        blue: { children: [], tags: [], vars: {} }
+      }
+    }
+
+    preview = runner.preview(snapshot: snapshot)
+
+    expect(preview['schema_version']).to eq('snapshot-import-preview-v1')
+    expect(preview['changes_applied']).to eq(false)
+    expect(preview['summary']).to include(
+      'hosts_created' => 1,
+      'groups_created' => 1,
+      'variables_changed' => 2,
+      'associations_added' => 4,
+      'ignored_existing_hosts' => 1,
+      'destructive_changes' => 0
+    )
+    expect(preview.dig('creates', 'hosts')).to eq(['web01'])
+    expect(preview.dig('creates', 'groups')).to eq(['blue'])
+    expect(preview.dig('updates', 'group_vars')).to include(
+      'entity' => 'web', 'name' => 'role', 'from' => 'old', 'to' => 'frontend'
+    )
+    expect(preview.dig('ignored', 'existing_hosts_not_in_snapshot')).to eq(['existing'])
+    expect(@db.models[:host].where(name: 'web01').count).to eq(0)
+    expect(@db.models[:group].where(name: 'blue').count).to eq(0)
+    expect(group.groupvars_dataset[name: 'role'][:value]).to eq('old')
+  end
+end
+# rubocop:enable Metrics/BlockLength

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/BlockLength
+require 'spec_helper'
+require 'inventory_context'
+require 'operations/inventory_doctor'
+
+RSpec.describe Moose::Inventory::Operations::InventoryDoctor 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 doctor(config: Moose::Inventory::Config)
+    described_class.new(context: Moose::Inventory::InventoryContext.new(db: @db), config: config)
+  end
+
+  it 'reports ok when the inventory and config have no findings' do
+    web = @db.models[:group].create(name: 'web')
+    host = @db.models[:host].create(name: 'web01')
+    host.add_group(web)
+
+    report = doctor.call
+
+    expect(report[:ok]).to eq(true)
+    expect(report[:issues]).to eq([])
+  end
+
+  it 'detects inventory health findings' do
+    ungrouped = @db.models[:group].create(name: 'ungrouped')
+    orphan = @db.models[:group].create(name: 'orphan')
+    duplicate = @db.models[:group].create(name: 'or-phan')
+    parent = @db.models[:group].create(name: 'parent')
+    child = @db.models[:group].create(name: 'child')
+    host = @db.models[:host].create(name: 'lonely')
+    bad_var = @db.models[:hostvar].create(name: '', value: 'oops')
+    host.add_group(ungrouped)
+    host.add_hostvar(bad_var)
+    parent.add_child(child)
+    child.add_child(parent)
+
+    report = doctor.call
+    @db.db[:groups_groups].delete
+
+    expect(report[:ok]).to eq(false)
+    expect(report[:issues].map { |issue| issue[:id] }).to include(
+      'host_only_in_ungrouped',
+      'orphaned_group',
+      'empty_group',
+      'duplicateish_group_names',
+      'invalid_variable_shape',
+      'circular_group_relationship'
+    )
+    expect(report[:issues].map { |issue| issue[:subject] }).to include(orphan.name)
+    expect(report[:issues].map { |issue| issue[:subject] }).to include([duplicate.name, orphan.name].sort)
+  end
+
+  it 'detects plaintext password configuration' do
+    config = instance_double('Config', db_settings: { adapter: 'mysql', password: 'secret' })
+
+    report = doctor(config: config).call
+
+    expect(report[:issues].map { |issue| issue[:id] }).to include('plaintext_password_config')
+  end
+end
+# rubocop:enable Metrics/BlockLength

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/BlockLength
+require 'spec_helper'
+require 'inventory_context'
+require 'operations/inventory_snapshot'
+
+RSpec.describe Moose::Inventory::Operations::InventorySnapshot 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
+
+  it 'exports hosts, groups, variables, and child relationships in canonical order' do
+    host = @db.models[:host].create(name: 'web01')
+    group = @db.models[:group].create(name: 'web')
+    child = @db.models[:group].create(name: 'blue')
+    hostvar = @db.models[:hostvar].create(name: 'env', value: 'prod')
+    groupvar = @db.models[:groupvar].create(name: 'role', value: 'frontend')
+    host.add_group(group)
+    host.add_hostvar(hostvar)
+    group.add_child(child)
+    group.add_groupvar(groupvar)
+
+    snapshot = described_class.new(context: Moose::Inventory::InventoryContext.new(db: @db)).export
+
+    expect(snapshot).to eq(
+      'version' => 1,
+      'hosts' => {
+        'web01' => { 'groups' => ['web'], 'tags' => [], 'vars' => { 'env' => 'prod' } }
+      },
+      'groups' => {
+        'blue' => { 'children' => [], 'tags' => [], 'vars' => {} },
+        'web' => { 'children' => ['blue'], 'tags' => [], 'vars' => { 'role' => 'frontend' } }
+      }
+    )
+  end
+end
+# rubocop:enable Metrics/BlockLength

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'inventory_context'
+require 'operations/remove_associations'
+
+RSpec.describe Moose::Inventory::Operations::RemoveAssociations 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 'removes groups from a host and reports missing associations and ungrouped reattachment' do
+    host = @db.models[:host].create(name: 'host1')
+    group = @db.models[:group].create(name: 'group1')
+    other = @db.models[:group].create(name: 'group2')
+    host.add_group(group)
+    host.add_group(other)
+
+    result = operation.host_from_groups(
+      host: host,
+      host_name: 'host1',
+      group_names: %w[group1 missing group2]
+    )
+
+    expect(result.warning_count).to eq(1)
+    expect(result.events.map(&:type)).to include(
+      :host_group_association_missing,
+      :adding_automatic_group
+    )
+    expect(host.groups_dataset[name: 'group1']).to be_nil
+    expect(host.groups_dataset[name: 'group2']).to be_nil
+    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')
+    host2 = @db.models[:host].create(name: 'host2')
+    extra = @db.models[:group].create(name: 'extra')
+    host2.add_group(extra)
+    group.add_host(host1)
+    group.add_host(host2)
+
+    result = operation.group_from_hosts(
+      group: group,
+      group_name: 'group1',
+      host_names: %w[host1 missing host2]
+    )
+
+    expect(result.warning_count).to eq(1)
+    expect(result.events.map(&:type)).to include(
+      :group_host_association_missing,
+      :adding_automatic_group
+    )
+    expect(group.hosts_dataset[name: 'host1']).to be_nil
+    expect(group.hosts_dataset[name: 'host2']).to be_nil
+    expect(host1.groups_dataset[name: 'ungrouped']).not_to be_nil
+    expect(host2.groups_dataset[name: 'ungrouped']).to be_nil
+  end
+end