moose-inventory 1.0.9 → 2.1

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'fileutils'
 require 'tmpdir'
@@ -5,17 +7,23 @@ require 'tmpdir'
 RSpec.describe 'Moose::Inventory::DB' do
   def with_db_config(db_config)
     saved_db = @db.instance_variable_get(:@db)
+    saved_models = @db.instance_variable_get(:@models)
+    saved_exceptions = @db.instance_variable_get(:@exceptions)
     saved_settings = @config._settings.dup
 
     begin
-      @db.instance_variable_set(:@db, nil)
+      @db.reset_runtime_state
+      @db.init_exceptions
       @config._settings.clear
       @config._settings[:config] = { db: db_config }
       yield
     ensure
       current_db = @db.instance_variable_get(:@db)
       current_db.disconnect if current_db.respond_to?(:disconnect)
+      @db.reset_runtime_state
       @db.instance_variable_set(:@db, saved_db)
+      @db.instance_variable_set(:@models, saved_models)
+      @db.instance_variable_set(:@exceptions, saved_exceptions)
       @config._settings.clear
       @config._settings.merge!(saved_settings)
     end
@@ -28,9 +36,9 @@ RSpec.describe 'Moose::Inventory::DB' 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 = []
@@ -69,39 +77,235 @@ RSpec.describe 'Moose::Inventory::DB' do
     end
 
     it 'raises a Moose DB exception for unsupported adapters' do
-      saved_db = @db.instance_variable_get(:@db)
-      saved_models = @db.instance_variable_get(:@models)
-      saved_exceptions = @db.instance_variable_get(:@exceptions)
-      saved_settings = @config._settings.dup
-
-      begin
-        @db.instance_variable_set(:@db, nil)
-        @db.instance_variable_set(:@models, nil)
-        @db.instance_variable_set(:@exceptions, nil)
-        @config._settings.clear
-        @config._settings[:config] = { db: { adapter: 'unsupported' } }
-
+      with_db_config(adapter: 'unsupported') do
         expect { @db.init }.to raise_error(
           Moose::Inventory::DB::MooseDBException,
           /database adapter unsupported is not yet supported/
         )
         expect(@db.exceptions[:moose]).to eq(Moose::Inventory::DB::MooseDBException)
-      ensure
-        @db.instance_variable_set(:@db, saved_db)
-        @db.instance_variable_set(:@models, saved_models)
-        @db.instance_variable_set(:@exceptions, saved_exceptions)
-        @config._settings.clear
-        @config._settings.merge!(saved_settings)
       end
     end
   end
 
+  describe 'existing database upgrade behavior' do
+    def with_sqlite_fixture(schema_version: nil, tables: [])
+      Dir.mktmpdir('moose-schema-fixture') do |dir|
+        dbfile = File.join(dir, 'inventory.sqlite3')
+        seed_sqlite_fixture(dbfile, schema_version: schema_version, tables: tables)
+
+        with_db_config(adapter: 'sqlite3', file: dbfile) do
+          yield dbfile
+        end
+      end
+    end
+
+    def seed_sqlite_fixture(dbfile, schema_version:, tables:)
+      fixture = Sequel.sqlite(dbfile)
+      tables.each { |table| create_fixture_table(fixture, table) }
+      unless schema_version.nil?
+        create_fixture_table(fixture, :schema_info)
+        fixture[:schema_info].insert(version: schema_version)
+      end
+    ensure
+      fixture&.disconnect
+    end
+
+    def create_fixture_table(db, table)
+      return if db.table_exists?(table)
+
+      @db::TABLE_DEFINITIONS.fetch(table).call(db)
+    end
+
+    def fixture_tables_through(version)
+      @db::SCHEMA_MIGRATIONS.values_at(*(1..version)).flatten
+    end
+
+    def expect_current_schema_after_init
+      @db.init
+      expect(@db.schema_version).to eq(@db::SCHEMA_VERSION)
+      expect(@db.status[:tables].values).to all(eq(true))
+    end
+
+    it 'declares ordered migrations through the current schema version' do
+      expect(@db.migration_versions).to eq((1..@db::SCHEMA_VERSION).to_a)
+    end
+
+    it 'exposes schema definitions from the schema migration module' do
+      expect(@db::SCHEMA_VERSION).to eq(@db::SchemaMigrations::SCHEMA_VERSION)
+      expect(@db::TABLE_DEFINITIONS).to equal(@db::SchemaMigrations::TABLE_DEFINITIONS)
+      expect(@db::SCHEMA_MIGRATIONS).to equal(@db::SchemaMigrations::SCHEMA_MIGRATIONS)
+      expect(@db::INDEX_DEFINITIONS).to equal(@db::SchemaMigrations::INDEX_DEFINITIONS)
+    end
+
+    it 'applies schema migrations one version at a time' do
+      with_sqlite_fixture(schema_version: 1, tables: %i[hosts groups schema_info]) do
+        @db.init_sqlite3
+
+        expect(@db).to receive(:apply_schema_migration!).ordered.with(1).and_call_original
+        expect(@db).to receive(:apply_schema_migration!).ordered.with(2).and_call_original
+        expect(@db).to receive(:apply_schema_migration!).ordered.with(3).and_call_original
+        expect(@db).to receive(:apply_schema_migration!).ordered.with(4).and_call_original
+
+        @db.migrate_schema!
+
+        expect(@db.schema_version).to eq(@db::SCHEMA_VERSION)
+        expect(@db.status[:tables][:audit_events]).to eq(true)
+        expect(@db.status[:tables][:tags]).to eq(true)
+      end
+    end
+
+    it 'creates unique and lookup indexes in schema version 4' do
+      expected = {
+        hostvars: :idx_hostvars_host_id_name,
+        groupvars: :idx_groupvars_group_id_name,
+        groups_hosts: :idx_groups_hosts_host_id_group_id,
+        groups_groups: :idx_groups_groups_parent_id_child_id,
+        hosts_tags: :idx_hosts_tags_host_id_tag_id,
+        groups_tags: :idx_groups_tags_group_id_tag_id
+      }
+
+      expected.each do |table, index_name|
+        expect(@db.db.indexes(table)).to include(index_name)
+        expect(@db.db.indexes(table).fetch(index_name)[:unique]).to eq(true)
+      end
+    end
+
+    it 'enforces unique host variable names per host' do
+      @db.reset
+      host = @db.models[:host].create(name: 'indexed-host')
+      @db.db[:hostvars].insert(host_id: host.id, name: 'env', value: 'prod')
+
+      expect do
+        @db.db[:hostvars].insert(host_id: host.id, name: 'env', value: 'prod')
+      end.to raise_error(Sequel::UniqueConstraintViolation)
+    end
+
+    it 'enforces unique host-group associations' do
+      @db.reset
+      host = @db.models[:host].create(name: 'indexed-host')
+      group = @db.models[:group].create(name: 'indexed-group')
+      @db.db[:groups_hosts].insert(host_id: host.id, group_id: group.id)
+
+      expect do
+        @db.db[:groups_hosts].insert(host_id: host.id, group_id: group.id)
+      end.to raise_error(Sequel::UniqueConstraintViolation)
+    end
+
+    it 'removes duplicate rows with identical values before adding unique indexes' do
+      with_sqlite_fixture(schema_version: 3, tables: fixture_tables_through(3)) do
+        @db.init_sqlite3
+        host_id = @db.db[:hosts].insert(name: 'dup-host')
+        group_id = @db.db[:groups].insert(name: 'dup-group')
+        @db.db[:hostvars].insert(host_id: host_id, name: 'env', value: 'prod')
+        @db.db[:hostvars].insert(host_id: host_id, name: 'env', value: 'prod')
+        @db.db[:groups_hosts].insert(host_id: host_id, group_id: group_id)
+        @db.db[:groups_hosts].insert(host_id: host_id, group_id: group_id)
+
+        @db.migrate_schema!
+
+        expect(@db.schema_version).to eq(@db::SCHEMA_VERSION)
+        expect(@db.db[:hostvars].where(host_id: host_id, name: 'env').count).to eq(1)
+        expect(@db.db[:groups_hosts].where(host_id: host_id, group_id: group_id).count).to eq(1)
+      end
+    end
+
+    it 'refuses index migration when duplicate variable rows have conflicting values' do
+      with_sqlite_fixture(schema_version: 3, tables: fixture_tables_through(3)) do
+        @db.init_sqlite3
+        host_id = @db.db[:hosts].insert(name: 'conflict-host')
+        @db.db[:hostvars].insert(host_id: host_id, name: 'env', value: 'prod')
+        @db.db[:hostvars].insert(host_id: host_id, name: 'env', value: 'dev')
+
+        expect { @db.migrate_schema! }.to raise_error(
+          Moose::Inventory::DB::MooseDBException,
+          /conflicting duplicates/
+        )
+      end
+    end
+
+    it 'upgrades a pre-schema-info sqlite database by creating missing additive tables' do
+      with_sqlite_fixture(tables: %i[hosts groups]) do
+        expect_current_schema_after_init
+      end
+    end
+
+    it 'upgrades a schema version 1 sqlite database to the current schema' do
+      with_sqlite_fixture(schema_version: 1, tables: %i[hosts groups]) do
+        expect_current_schema_after_init
+      end
+    end
+
+    it 'upgrades a schema version 2 sqlite database to the current schema' do
+      with_sqlite_fixture(schema_version: 2, tables: %i[hosts groups schema_info]) do
+        expect_current_schema_after_init
+      end
+    end
+
+    it 'opens a current sqlite database without changing its schema version' do
+      with_sqlite_fixture(schema_version: @db::SCHEMA_VERSION, tables: %i[hosts groups schema_info tags]) do
+        expect_current_schema_after_init
+      end
+    end
+
+    it 'refuses to open a database from a future schema version' do
+      with_sqlite_fixture(schema_version: @db::SCHEMA_VERSION + 1, tables: %i[hosts groups schema_info]) do
+        expect { @db.init }.to raise_error(
+          Moose::Inventory::DB::MooseDBException,
+          /newer than supported version #{@db::SCHEMA_VERSION}/
+        )
+      end
+    end
+
+    it 'refuses to migrate a database from a future schema version' do
+      with_sqlite_fixture(schema_version: @db::SCHEMA_VERSION + 1, tables: %i[hosts groups schema_info]) do
+        @db.init_sqlite3
+
+        expect { @db.migrate! }.to raise_error(
+          Moose::Inventory::DB::MooseDBException,
+          /newer than supported version #{@db::SCHEMA_VERSION}/
+        )
+      end
+    end
+
+    it 'repairs dirty partial schemas during startup without changing the final schema version' do
+      with_sqlite_fixture(schema_version: @db::SCHEMA_VERSION, tables: %i[hosts groups schema_info]) do
+        @db.init
+
+        status = @db.status
+
+        expect(status[:schema_version]).to eq(@db::SCHEMA_VERSION)
+        expect(status[:tables].values).to all(eq(true))
+      end
+    end
+  end
   describe '.init_exceptions()' do
     it 'is responsive' do
       expect(@db.respond_to?(:init_exceptions)).to eq(true)
     end
   end
 
+  describe '.reset_runtime_state()' do
+    it 'clears cached db, models, and exceptions' do
+      saved_db = @db.instance_variable_get(:@db)
+      saved_models = @db.instance_variable_get(:@models)
+      saved_exceptions = @db.instance_variable_get(:@exceptions)
+
+      @db.instance_variable_set(:@db, :fake_db)
+      @db.instance_variable_set(:@models, { fake: true })
+      @db.instance_variable_set(:@exceptions, { fake: true })
+
+      @db.reset_runtime_state
+
+      expect(@db.db).to be_nil
+      expect(@db.models).to be_nil
+      expect(@db.exceptions).to be_nil
+
+      @db.instance_variable_set(:@db, saved_db)
+      @db.instance_variable_set(:@models, saved_models)
+      @db.instance_variable_set(:@exceptions, saved_exceptions)
+    end
+  end
+
   describe '.connect()' do
     it 'dispatches the documented sqlite3 adapter to the sqlite initializer' do
       with_db_config(adapter: 'sqlite3') do
@@ -146,18 +350,20 @@ RSpec.describe 'Moose::Inventory::DB' do
 
     it 'creates nested parent directories for configured database files' do
       saved_db = @db.instance_variable_get(:@db)
+      saved_models = @db.instance_variable_get(:@models)
+      saved_exceptions = @db.instance_variable_get(:@exceptions)
       saved_settings = @config._settings.dup
       tmpdir = Dir.mktmpdir('moose-inventory-sqlite')
       nested_dbfile = File.join(tmpdir, 'one', 'two', 'inventory.db')
 
       begin
-        @db.instance_variable_set(:@db, nil)
+        @db.reset_runtime_state
         @config._settings.clear
         @config._settings[:config] = {
           db: {
             adapter: 'sqlite3',
-            file: nested_dbfile,
-          },
+            file: nested_dbfile
+          }
         }
 
         @db.init_sqlite3
@@ -167,7 +373,10 @@ RSpec.describe 'Moose::Inventory::DB' do
       ensure
         current_db = @db.instance_variable_get(:@db)
         current_db.disconnect if current_db.respond_to?(:disconnect)
+        @db.reset_runtime_state
         @db.instance_variable_set(:@db, saved_db)
+        @db.instance_variable_set(:@models, saved_models)
+        @db.instance_variable_set(:@exceptions, saved_exceptions)
         @config._settings.clear
         @config._settings.merge!(saved_settings)
         FileUtils.remove_entry(tmpdir) if tmpdir && Dir.exist?(tmpdir)
@@ -190,6 +399,59 @@ RSpec.describe 'Moose::Inventory::DB' do
       end
     end
 
+    it 'raises a Moose DB exception when password and password_env are missing' do
+      with_db_config(
+        adapter: 'mysql',
+        host: 'localhost',
+        database: 'moose_inventory_test',
+        user: 'moose'
+      ) do
+        expect { @db.init_mysql }.to raise_error(
+          Moose::Inventory::DB::MooseDBException,
+          /Expected key password or password_env missing in mysql configuration/
+        )
+      end
+    end
+
+    it 'uses a mysql password from the configured environment variable' do
+      saved_db = @db.instance_variable_get(:@db)
+      saved_settings = @config._settings.dup
+      saved_password = ENV.fetch('MOOSE_INVENTORY_MYSQL_PASSWORD', nil)
+      mysql_config = {
+        adapter: 'mysql',
+        host: 'localhost',
+        database: 'moose_inventory_test',
+        user: 'moose',
+        password_env: 'MOOSE_INVENTORY_MYSQL_PASSWORD'
+      }
+
+      begin
+        ENV['MOOSE_INVENTORY_MYSQL_PASSWORD'] = 'env-secret'
+        @db.instance_variable_set(:@db, nil)
+        @config._settings.clear
+        @config._settings[:config] = { db: mysql_config }
+
+        expect(Sequel).to receive(:mysql2).with(
+          user: 'moose',
+          password: 'env-secret',
+          host: 'localhost',
+          database: 'moose_inventory_test'
+        ).and_return(:mysql2_connection)
+
+        @db.init_mysql
+        expect(@db.db).to eq(:mysql2_connection)
+      ensure
+        if saved_password.nil?
+          ENV.delete('MOOSE_INVENTORY_MYSQL_PASSWORD')
+        else
+          ENV['MOOSE_INVENTORY_MYSQL_PASSWORD'] = saved_password
+        end
+        @db.instance_variable_set(:@db, saved_db)
+        @config._settings.clear
+        @config._settings.merge!(saved_settings)
+      end
+    end
+
     it 'uses the mysql2 Sequel adapter with configured connection settings' do
       saved_db = @db.instance_variable_get(:@db)
       saved_settings = @config._settings.dup
@@ -198,7 +460,7 @@ RSpec.describe 'Moose::Inventory::DB' do
         host: 'localhost',
         database: 'moose_inventory_test',
         user: 'moose',
-        password: 'secret',
+        password: 'secret'
       }
 
       begin
@@ -238,6 +500,67 @@ RSpec.describe 'Moose::Inventory::DB' do
       end
     end
 
+    it 'raises a Moose DB exception when password_env points to an unset variable' do
+      saved_password = ENV.fetch('MOOSE_INVENTORY_POSTGRES_PASSWORD', nil)
+      ENV.delete('MOOSE_INVENTORY_POSTGRES_PASSWORD')
+
+      begin
+        with_db_config(
+          adapter: 'postgresql',
+          host: 'localhost',
+          database: 'moose_inventory_test',
+          user: 'moose',
+          password_env: 'MOOSE_INVENTORY_POSTGRES_PASSWORD'
+        ) do
+          expect { @db.init_postgresql }.to raise_error(
+            Moose::Inventory::DB::MooseDBException,
+            /Environment variable MOOSE_INVENTORY_POSTGRES_PASSWORD is not set for postgresql password/
+          )
+        end
+      ensure
+        ENV['MOOSE_INVENTORY_POSTGRES_PASSWORD'] = saved_password unless saved_password.nil?
+      end
+    end
+
+    it 'uses a postgresql password from the configured environment variable' do
+      saved_db = @db.instance_variable_get(:@db)
+      saved_settings = @config._settings.dup
+      saved_password = ENV.fetch('MOOSE_INVENTORY_POSTGRES_PASSWORD', nil)
+      postgresql_config = {
+        adapter: 'postgresql',
+        host: 'localhost',
+        database: 'moose_inventory_test',
+        user: 'moose',
+        password_env: 'MOOSE_INVENTORY_POSTGRES_PASSWORD'
+      }
+
+      begin
+        ENV['MOOSE_INVENTORY_POSTGRES_PASSWORD'] = 'env-secret'
+        @db.instance_variable_set(:@db, nil)
+        @config._settings.clear
+        @config._settings[:config] = { db: postgresql_config }
+
+        expect(Sequel).to receive(:postgres).with(
+          user: 'moose',
+          password: 'env-secret',
+          host: 'localhost',
+          database: 'moose_inventory_test'
+        ).and_return(:postgresql_connection)
+
+        @db.init_postgresql
+        expect(@db.db).to eq(:postgresql_connection)
+      ensure
+        if saved_password.nil?
+          ENV.delete('MOOSE_INVENTORY_POSTGRES_PASSWORD')
+        else
+          ENV['MOOSE_INVENTORY_POSTGRES_PASSWORD'] = saved_password
+        end
+        @db.instance_variable_set(:@db, saved_db)
+        @config._settings.clear
+        @config._settings.merge!(saved_settings)
+      end
+    end
+
     it 'uses the postgres Sequel adapter with configured connection settings' do
       saved_db = @db.instance_variable_get(:@db)
       saved_settings = @config._settings.dup
@@ -246,7 +569,7 @@ RSpec.describe 'Moose::Inventory::DB' do
         host: 'localhost',
         database: 'moose_inventory_test',
         user: 'moose',
-        password: 'secret',
+        password: 'secret'
       }
 
       begin
@@ -327,6 +650,70 @@ RSpec.describe 'Moose::Inventory::DB' do
     end
   end
 
+  describe '.busy_retry_delay()' do
+    it 'uses deterministic capped exponential backoff delays' do
+      expect(@db.busy_retry_delay(1)).to eq(0.05)
+      expect(@db.busy_retry_delay(2)).to eq(0.1)
+      expect(@db.busy_retry_delay(5)).to eq(0.8)
+      expect(@db.busy_retry_delay(6)).to eq(1.0)
+      expect(@db.busy_retry_delay(10)).to eq(1.0)
+    end
+  end
+
+  describe '.busy_database_error?()' do
+    it 'identifies Sequel busy database errors by message' do
+      expect(@db.busy_database_error?(Sequel::DatabaseError.new('BusyException: locked'))).to eq(true)
+      expect(@db.busy_database_error?(Sequel::DatabaseError.new('other database failure'))).to eq(false)
+    end
+  end
+
+  describe '.retry_busy_transaction()' do
+    it 'sleeps for the deterministic retry delay before another busy retry' do
+      delays = []
+      error = Sequel::DatabaseError.new('BusyException: database is locked')
+
+      @db.retry_busy_transaction(error, 3, sleeper: ->(delay) { delays << delay })
+
+      expect(delays).to eq([0.2])
+    end
+
+    it 'raises the original error when the retry limit is exceeded' do
+      error = Sequel::DatabaseError.new('BusyException: database is locked')
+
+      actual_stderr = capture(:STDERR) do
+        expect { @db.retry_busy_transaction(error, 11, sleeper: ->(_delay) {}) }
+          .to raise_error(error)
+      end
+
+      expect(actual_stderr).to include('The database appears to be locked by another process')
+    end
+  end
+
+  describe '.purge()' do
+    it 'uses drop_table for non-sqlite adapters' do
+      saved_db = @db.instance_variable_get(:@db)
+
+      begin
+        fake_db = instance_double('DB')
+        @db.instance_variable_set(:@db, fake_db)
+        allow(@db).to receive(:sqlite_adapter?).and_return(false)
+        expect(fake_db).to receive(:drop_table).with(
+          :hosts,
+          :hostvars,
+          :groups,
+          :groupvars,
+          :group_hosts,
+          if_exists: true,
+          cascade: true
+        )
+
+        @db.purge
+      ensure
+        @db.instance_variable_set(:@db, saved_db)
+      end
+    end
+  end
+
   describe '.reset()' do
     it 'should be responsive' do
       result = @db.respond_to?(:reset)
@@ -341,7 +728,6 @@ RSpec.describe 'Moose::Inventory::DB' do
       # Reset the DB
       @db.reset
 
-      #
       hosts = @db.models[:host].all
       expect(hosts.count).to eq(0)
 
@@ -360,6 +746,57 @@ RSpec.describe 'Moose::Inventory::DB' do
       expect(result).to eq(true)
     end
 
+    it 'retries busy database transactions before succeeding' do
+      saved_db = @db.instance_variable_get(:@db)
+      fake_db = Class.new do
+        attr_reader :attempts
+
+        def initialize(error)
+          @error = error
+          @attempts = 0
+        end
+
+        def transaction(savepoint:)
+          raise ArgumentError, 'expected savepoint' unless savepoint
+
+          @attempts += 1
+          raise @error if @attempts == 1
+
+          yield
+        end
+      end.new(Sequel::DatabaseError.new('BusyException: database is locked'))
+
+      begin
+        @db.instance_variable_set(:@db, fake_db)
+        allow(@db).to receive(:retry_busy_transaction)
+
+        result = @db.transaction { :ok }
+
+        expect(result).to eq(:ok)
+        expect(fake_db.attempts).to eq(2)
+        expect(@db).to have_received(:retry_busy_transaction).once
+      ensure
+        @db.instance_variable_set(:@db, saved_db)
+      end
+    end
+
+    it 're-raises non-busy database errors without retrying' do
+      saved_db = @db.instance_variable_get(:@db)
+      error = Sequel::DatabaseError.new('constraint failed')
+      fake_db = instance_double('DB')
+
+      begin
+        @db.instance_variable_set(:@db, fake_db)
+        allow(fake_db).to receive(:transaction).and_raise(error)
+        allow(@db).to receive(:retry_busy_transaction)
+
+        expect { @db.transaction { :ignored } }.to raise_error(error)
+        expect(@db).not_to have_received(:retry_busy_transaction)
+      ensure
+        @db.instance_variable_set(:@db, saved_db)
+      end
+    end
+
     it 'should perform transactions' do
       hosts = @db.models[:host].all
       count = { initial: hosts.count, items: 0 }
@@ -391,7 +828,7 @@ RSpec.describe 'Moose::Inventory::DB' do
           count[:items] = count[:items] + 1
           @db.models[:host].create(name: "rollback-#{count[:items]}")
         end
-        fail Sequel::Rollback, 'Test error' #
+        raise Sequel::Rollback, 'Test error'
       end
 
       hosts = @db.models[:host].all
@@ -402,5 +839,90 @@ RSpec.describe 'Moose::Inventory::DB' do
 
       expect(count[:final]).to eq(count[:initial])
     end
+
+    it 'prints concise Moose DB transaction errors by default' do
+      saved_trace = @config._confopts[:trace]
+      @config._confopts[:trace] = false
+
+      begin
+        actual = runner do
+          @db.transaction do
+            raise @db.exceptions[:moose], 'Trace regression target'
+          end
+        end
+      ensure
+        @config._confopts[:trace] = saved_trace
+      end
+
+      expect(actual[:unexpected]).to eq(false)
+      expect(actual[:aborted]).to eq(true)
+      expect(actual[:STDERR]).to eq(
+        "An error occurred during a transaction, any changes have been rolled back.\n" \
+        "ERROR: Trace regression target\n"
+      )
+    end
+
+    it 'prints the Moose DB exception backtrace when trace is enabled' do
+      saved_trace = @config._confopts[:trace]
+      @config._confopts[:trace] = true
+
+      begin
+        actual = runner do
+          @db.transaction do
+            raise @db.exceptions[:moose], 'Trace regression target'
+          end
+        end
+      ensure
+        @config._confopts[:trace] = saved_trace
+      end
+
+      expect(actual[:unexpected]).to eq(false)
+      expect(actual[:aborted]).to eq(true)
+      expect(actual[:STDERR]).to include(
+        "An error occurred during a transaction, any changes have been rolled back.\n"
+      )
+      expect(actual[:STDERR]).to include('Moose::Inventory::DB::MooseDBException')
+      expect(actual[:STDERR]).to include('Trace regression target')
+      expect(actual[:STDERR]).to include('spec/lib/moose_inventory/db/db_spec.rb')
+      expect(actual[:STDERR]).to include("ERROR: Trace regression target\n")
+      expect(actual[:STDERR]).not_to include('NoMethodError')
+    end
+
+    it 'warns and re-raises ordinary StandardError failures' do
+      actual = runner do
+        @db.transaction do
+          raise 'generic failure'
+        end
+      end
+
+      expect(actual[:aborted]).to eq(false)
+      expect(actual[:unexpected].class).to eq(RuntimeError)
+      expect(actual[:unexpected].message).to eq('generic failure')
+      expect(actual[:STDERR]).to eq(
+        "An error occurred during a transaction, any changes have been rolled back.\n"
+      )
+    end
+
+    it 'warns and re-raises SystemExit failures triggered inside the transaction' do
+      actual = runner do
+        @db.transaction do
+          raise SystemExit.new(7), 'stop now'
+        end
+      end
+
+      expect(actual[:unexpected]).to eq(false)
+      expect(actual[:aborted]).to eq(true)
+      expect(actual[:STDERR]).to eq(
+        "An error occurred during a transaction, any changes have been rolled back.\n"
+      )
+    end
+
+    it 'does not swallow non-rescued fatal exceptions such as interrupts' do
+      expect do
+        @db.transaction do
+          raise Interrupt, 'ctrl-c'
+        end
+      end.to raise_error(Interrupt, 'ctrl-c')
+    end
   end
 end