moose-inventory 1.0.8 → 2.0

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

@@ -1,6 +1,26 @@
 require 'spec_helper'
+require 'fileutils'
+require 'tmpdir'
 
 RSpec.describe 'Moose::Inventory::DB' do
+  def with_db_config(db_config)
+    saved_db = @db.instance_variable_get(:@db)
+    saved_settings = @config._settings.dup
+
+    begin
+      @db.instance_variable_set(:@db, nil)
+      @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.instance_variable_set(:@db, saved_db)
+      @config._settings.clear
+      @config._settings.merge!(saved_settings)
+    end
+  end
+
   #=============================
   # Initialization
   #
@@ -10,7 +30,7 @@ RSpec.describe 'Moose::Inventory::DB' do
     @mockarg_parts = {
       config:  File.join(spec_root, 'config/config.yml'),
       format:  'yaml',
-      env:     'test'
+      env:     'test',
     }
 
     @mockargs = []
@@ -22,7 +42,7 @@ RSpec.describe 'Moose::Inventory::DB' do
     @config = Moose::Inventory::Config
     @config.init(@mockargs)
 
-    @db      = Moose::Inventory::DB
+    @db = Moose::Inventory::DB
   end
 
   #=============================
@@ -47,6 +67,322 @@ RSpec.describe 'Moose::Inventory::DB' do
 
       expect(failed).to eq(false)
     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' } }
+
+        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 '.init_exceptions()' do
+    it 'is responsive' do
+      expect(@db.respond_to?(:init_exceptions)).to eq(true)
+    end
+  end
+
+  describe '.connect()' do
+    it 'dispatches the documented sqlite3 adapter to the sqlite initializer' do
+      with_db_config(adapter: 'sqlite3') do
+        expect(@db).to receive(:init_sqlite3) do
+          @db.instance_variable_set(:@db, :sqlite_connection)
+        end
+        @db.connect
+        expect(@db.db).to eq(:sqlite_connection)
+      end
+    end
+
+    it 'dispatches the documented mysql adapter to the mysql initializer' do
+      with_db_config(adapter: 'mysql') do
+        expect(@db).to receive(:init_mysql) do
+          @db.instance_variable_set(:@db, :mysql_connection)
+        end
+        @db.connect
+        expect(@db.db).to eq(:mysql_connection)
+      end
+    end
+
+    it 'dispatches the documented postgresql adapter to the postgresql initializer' do
+      with_db_config(adapter: 'postgresql') do
+        expect(@db).to receive(:init_postgresql) do
+          @db.instance_variable_set(:@db, :postgresql_connection)
+        end
+        @db.connect
+        expect(@db.db).to eq(:postgresql_connection)
+      end
+    end
+  end
+
+  describe '.init_sqlite3()' do
+    it 'raises a Moose DB exception when the configured database file is missing' do
+      with_db_config(adapter: 'sqlite3') do
+        expect { @db.init_sqlite3 }.to raise_error(
+          Moose::Inventory::DB::MooseDBException,
+          /Expected key file missing in sqlite3 configuration/
+        )
+      end
+    end
+
+    it 'creates nested parent directories for configured database files' do
+      saved_db = @db.instance_variable_get(:@db)
+      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)
+        @config._settings.clear
+        @config._settings[:config] = {
+          db: {
+            adapter: 'sqlite3',
+            file: nested_dbfile,
+          },
+        }
+
+        @db.init_sqlite3
+
+        expect(File.directory?(File.dirname(nested_dbfile))).to eq(true)
+        expect(File.file?(nested_dbfile)).to eq(true)
+      ensure
+        current_db = @db.instance_variable_get(:@db)
+        current_db.disconnect if current_db.respond_to?(:disconnect)
+        @db.instance_variable_set(:@db, saved_db)
+        @config._settings.clear
+        @config._settings.merge!(saved_settings)
+        FileUtils.remove_entry(tmpdir) if tmpdir && Dir.exist?(tmpdir)
+      end
+    end
+  end
+
+  describe '.init_mysql()' do
+    it 'raises a Moose DB exception when a required connection key is missing' do
+      with_db_config(
+        adapter: 'mysql',
+        database: 'moose_inventory_test',
+        user: 'moose',
+        password: 'secret'
+      ) do
+        expect { @db.init_mysql }.to raise_error(
+          Moose::Inventory::DB::MooseDBException,
+          /Expected key host missing in mysql configuration/
+        )
+      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['MOOSE_INVENTORY_MYSQL_PASSWORD']
+      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
+      mysql_config = {
+        adapter: 'mysql',
+        host: 'localhost',
+        database: 'moose_inventory_test',
+        user: 'moose',
+        password: 'secret',
+      }
+
+      begin
+        @db.instance_variable_set(:@db, nil)
+        @config._settings.clear
+        @config._settings[:config] = { db: mysql_config }
+
+        expect(Sequel).to receive(:mysql2).with(
+          user: 'moose',
+          password: 'secret',
+          host: 'localhost',
+          database: 'moose_inventory_test'
+        ).and_return(:mysql2_connection)
+
+        @db.init_mysql
+        expect(@db.db).to eq(:mysql2_connection)
+      ensure
+        @db.instance_variable_set(:@db, saved_db)
+        @config._settings.clear
+        @config._settings.merge!(saved_settings)
+      end
+    end
+  end
+
+  describe '.init_postgresql()' do
+    it 'raises a Moose DB exception when a required connection key is missing' do
+      with_db_config(
+        adapter: 'postgresql',
+        host: 'localhost',
+        database: 'moose_inventory_test',
+        password: 'secret'
+      ) do
+        expect { @db.init_postgresql }.to raise_error(
+          Moose::Inventory::DB::MooseDBException,
+          /Expected key user missing in postgresql configuration/
+        )
+      end
+    end
+
+    it 'raises a Moose DB exception when password_env points to an unset variable' do
+      saved_password = ENV['MOOSE_INVENTORY_POSTGRES_PASSWORD']
+      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['MOOSE_INVENTORY_POSTGRES_PASSWORD']
+      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
+      postgresql_config = {
+        adapter: 'postgresql',
+        host: 'localhost',
+        database: 'moose_inventory_test',
+        user: 'moose',
+        password: 'secret',
+      }
+
+      begin
+        @db.instance_variable_set(:@db, nil)
+        @config._settings.clear
+        @config._settings[:config] = { db: postgresql_config }
+
+        expect(Sequel).to receive(:postgres).with(
+          user: 'moose',
+          password: 'secret',
+          host: 'localhost',
+          database: 'moose_inventory_test'
+        ).and_return(:postgresql_connection)
+
+        @db.init_postgresql
+        expect(@db.db).to eq(:postgresql_connection)
+      ensure
+        @db.instance_variable_set(:@db, saved_db)
+        @config._settings.clear
+        @config._settings.merge!(saved_settings)
+      end
+    end
   end
 
   describe '.db' do
@@ -180,5 +516,53 @@ 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
+            fail @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
+            fail @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
   end
 end

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

@@ -10,7 +10,7 @@ RSpec.describe 'models' do
     @mockarg_parts = {
       config:  File.join(spec_root, 'config/config.yml'),
       format:  'yaml',
-      env:     'test'
+      env:     'test',
     }
 
     @mockargs = []
@@ -128,45 +128,44 @@ RSpec.describe 'models' do
     end
 
     it 'should have a many-to-many self-referential relationship (i.e. GROUPS of GROUPS)' do
-      
       parent1 = @db.models[:group].create(name: 'parent1')
       parent2 = @db.models[:group].create(name: 'parent2')
       child1 = @db.models[:group].create(name: 'child1')
       child2 = @db.models[:group].create(name: 'child2')
 
-      parent1.add_child(child1)  
+      parent1.add_child(child1)
       parent1.add_child(child2)
 
-      parent2.add_child(child1)  
+      parent2.add_child(child1)
       parent2.add_child(child2)
-      
+
       group = @db.models[:group].find(name: 'parent1')
       children = group.children_dataset
 
       expect(children).not_to be_nil
       expect(children.count).to eq(2)
-      
+
       group = @db.models[:group].find(name: 'parent2')
       children = group.children_dataset
 
       expect(children).not_to be_nil
       expect(children.count).to eq(2)
     end
-     
+
     it 'should have relationships with Hostvars' do
       groupname = 'group-test'
       groupvarname = 'groupvar-test'
       groupvarval = '1'
-  
+
       group = @db.models[:group].create(name: groupname)
       groupvar = @db.models[:groupvar].create(name: groupvarname,
                                               value: groupvarval)
-  
+
       group.add_groupvar(groupvar)
-  
+
       group = @db.models[:group].find(name: groupname)
       groupvars = group.groupvars_dataset
-  
+
       expect(groupvars).not_to be_nil
       expect(groupvars.count).to eq(1)
       expect(groupvars.first[:name]).to eq(groupvarname)

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

@@ -0,0 +1,77 @@
+# 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 '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,65 @@
+# 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 '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,69 @@
+# 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 '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