moose-inventory 2.0 → 2.1

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

@@ -50,6 +50,40 @@ RSpec.describe Moose::Inventory::Operations::AddAssociations do
     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')

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

@@ -40,6 +40,21 @@ RSpec.describe Moose::Inventory::Operations::AddGroups do
     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')

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

@@ -43,6 +43,19 @@ RSpec.describe Moose::Inventory::Operations::AddHosts do
       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')

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

@@ -46,6 +46,52 @@ RSpec.describe Moose::Inventory::Operations::GroupChildRelations do
     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')

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