facterdb 0.7.0 → 0.8.0

data/lib/facterdb/version.rb

@@ -1,5 +1,5 @@
 module FacterDB
   module Version
-    STRING = '0.7.0'
+    STRING = '0.8.0'
   end
 end

data/rakelib/rhel_alts.rake

@@ -0,0 +1,24 @@
+desc 'Create RHEL/OracleLinux/Scientific factsets from CentOS factsets'
+task :rhel_alts do
+  Dir[File.join(__dir__, '..', 'facts', '*', 'centos-*-x86_64.facts')].each do |f|
+    centos_factset = File.read(f)
+
+    rhel_path = f.gsub(%r{centos-}, 'redhat-')
+    File.open(rhel_path, 'w') do |fd|
+      fd.puts centos_factset.gsub(%r{CentOS}, 'RedHat')
+    end
+
+    oracle_path = f.gsub(%r{centos-}, 'oraclelinux-')
+    File.open(oracle_path, 'w') do |fd|
+      fd.puts centos_factset.gsub(%r{CentOS}, 'OracleLinux')
+    end
+
+    # Scientific isn't going to be updated to 8
+    if File.basename(f)[%r{-(\d+)-}, 1].to_i <= 7
+      scientific_path = f.gsub(%r{centos-}, 'scientific-')
+      File.open(scientific_path, 'w') do |fd|
+        fd.puts centos_factset.gsub(%r{CentOS}, 'Scientific')
+      end
+    end
+  end
+end

data/spec/facterdb_spec.rb

@@ -1,181 +1,319 @@
 require 'spec_helper'
 
-describe 'FacterDB' do
+describe FacterDB do
+  shared_examples 'returns a result' do
+    it 'returns an Array' do
+      expect(result).to be_an_instance_of(Array)
+    end
+
+    it 'returns at least 1 result' do
+      expect(result).not_to be_empty
+    end
+
+    it 'returns an Array of Hashes' do
+      expect(result).to all(be_an_instance_of(Hash))
+    end
+  end
+
+  let(:facts_24_path)  { File.join(project_dir, 'facts', '2.4') }
+  let(:facts_24_count) { Dir.glob(File.join(facts_24_path,'*.facts')).count }
+  let(:facts_23_path)  { File.join(project_dir, 'facts', '2.3') }
+  let(:facts_23_count) { Dir.glob(File.join(facts_23_path,'*.facts')).count }
 
-  describe 'database' do
+  describe '.use_defaultdb?' do
+    subject { described_class.use_defaultdb? }
 
     before(:each) do
-      ENV['FACTERDB_SKIP_DEFAULTDB'] = nil
-      FacterDB.instance_variable_set(:@database, nil)
+      ENV.delete('FACTERDB_SKIP_DEFAULTDB')
+    end
+
+    context 'when FACTERDB_SKIP_DEFAULTDB environment variable is unset' do
+      it { is_expected.to be_truthy }
     end
 
-    it 'skip default facts' do
-      ENV['FACTERDB_SKIP_DEFAULTDB'] = 'true'
-      expect(FacterDB.use_defaultdb?).to eq(false)
+    context 'when FACTERDB_SKIP_DEFAULTDB environment variable is set' do
+      before(:each) do
+        ENV['FACTERDB_SKIP_DEFAULTDB'] = '1'
+      end
+
+      it { is_expected.to be_falsey }
     end
+  end
+
+  describe '.external_fact_files' do
+    subject(:file_count) { described_class.external_fact_files.count }
 
-    it 'use default facts' do
-      expect(FacterDB.use_defaultdb?).to eq(true)
+    let(:non_directory_path) { File.join('this', 'is', 'not', 'a', 'directory') }
+
+    before(:each) do
+      ENV.delete('FACTERDB_SEARCH_PATHS')
+      allow(File).to receive(:directory?).and_call_original
+      allow(File).to receive(:directory?).with(non_directory_path).and_return(false)
     end
 
-    it '#external_fact_files with env variable' do
-      ENV['FACTERDB_SEARCH_PATHS'] = File.join(project_dir, 'facts', '2.4')
-      expect(FacterDB.external_fact_files.count).to be >= 50
+    context 'without an argument or FACTERDB_SEARCH_PATHS environment variable set' do
+      it { is_expected.to be_zero }
     end
 
-    it '#external_fact_files with env variable and multiple paths' do
-      ENV['FACTERDB_SEARCH_PATHS'] = [File.join(project_dir, 'facts', '2.4'), File.join(project_dir, 'facts', '2.3')].join(File::PATH_SEPARATOR)
-      expect(FacterDB.external_fact_files.count).to be >= 150
+    context 'when the FACTERDB_SEARCH_PATHS environment variable is set' do
+      it 'supports a single path' do
+        ENV['FACTERDB_SEARCH_PATHS'] = facts_24_path
+
+        expect(file_count).to eq(facts_24_count)
+      end
+
+      it 'supports multiple paths delimited by the OS path separator' do
+        ENV['FACTERDB_SEARCH_PATHS'] = [facts_24_path, facts_23_path].join(File::PATH_SEPARATOR)
+
+        expect(file_count).to eq(facts_24_count + facts_23_count)
+      end
+
+      it 'ignores paths that are not a directory' do
+        ENV['FACTERDB_SEARCH_PATHS'] = [facts_24_path, non_directory_path].join(File::PATH_SEPARATOR)
+
+        object = defined?(Warning) ? Warning : Kernel
+        allow(object).to receive(:warn).and_call_original
+        allow(object).to receive(:warn).with(a_string_matching(%r{is not a directory}))
+
+        expect(file_count).to eq(facts_24_count)
+      end
     end
 
-    it '#external_fact_files with argument' do
-      ENV['FACTERDB_SEARCH_PATHS'] = nil
-      path = File.join(project_dir, 'facts', '2.4')
-      expect(FacterDB.external_fact_files(path).count).to be >= 102
+    # TODO: There is no parameter validation in this method
+    context 'when passed an argument' do
+      subject(:file_count) { described_class.external_fact_files(fact_paths).count }
+
+      context 'that is a single path' do
+        let(:fact_paths) { facts_24_path }
+
+        it 'returns the paths to the fact sets in the specified path' do
+          expect(file_count).to eq(facts_24_count)
+        end
+      end
+
+      context 'that is multiple paths delimited by the OS path separator' do
+        let(:fact_paths) { [facts_24_path, facts_23_path].join(File::PATH_SEPARATOR) }
+
+        it 'returns the paths to the fact sets in all the specified paths' do
+          expect(file_count).to eq(facts_24_count + facts_23_count)
+        end
+      end
+
+      context 'that contains a path that is not a directory' do
+        let(:fact_paths) { [facts_24_path, non_directory_path].join(File::PATH_SEPARATOR) }
+
+        it 'ignores the path that is not a directory' do
+          object = defined?(Warning) ? Warning : Kernel
+          allow(object).to receive(:warn).and_call_original
+          allow(object).to receive(:warn).with(a_string_matching(%r{is not a directory}))
+
+          expect(file_count).to eq(facts_24_count)
+        end
+      end
     end
+  end
+
+  describe '.default_fact_files' do
+    subject(:default_fact_files) { described_class.default_fact_files }
 
-    it '#external_fact_files without argument or env variable' do
-      ENV['FACTERDB_SEARCH_PATHS'] = nil
-      expect(FacterDB.external_fact_files.count).to be 0
+    before(:each) do
+      ENV.delete('FACTERDB_SKIP_DEFAULTDB')
     end
 
-    it '#default_fact_files' do
-      expect(FacterDB.default_fact_files.count).to be >= 1000
+    context 'when FACTERDB_SKIP_DEFAULTDB environment variable is not set' do
+      it 'returns the list of fact sets included in FacterDB' do
+        # This test is a little naive but works
+        expect(default_fact_files.count).to be >= 1000
+      end
     end
 
-    it '#facterdb_fact_files' do
-      ENV['FACTERDB_SEARCH_PATHS'] = File.join(project_dir, 'facts', '2.4')
-      external_count = FacterDB.external_fact_files.count
-      internal_count = FacterDB.default_fact_files.count
-      # because we call unique on the array we remove the duplicates which skews this test
-      expect(FacterDB.facterdb_fact_files.count).to eq(internal_count)
+    context 'when FACTERDB_SKIP_DEFAULTDB environment variable is set' do
+      before(:each) do
+        ENV['FACTERDB_SKIP_DEFAULTDB'] = '1'
+      end
+
+      it { is_expected.to be_empty }
     end
+  end
+
+  describe '.facterdb_fact_files' do
+    subject(:facterdb_fact_files) { described_class.facterdb_fact_files }
 
-    it '#database' do
-      ENV['FACTERDB_SEARCH_PATHS'] = nil
-      # to be an incomprehensible string
-       expect(FacterDB.database).to be_a String
+    before(:each) do
+      ENV.delete('FACTERDB_SKIP_DEFAULTDB')
     end
 
-    it '#database with external paths' do
-      ENV['FACTERDB_SEARCH_PATHS'] = File.join(project_dir, 'facts', '2.4')
-      # to be an incomprehensible string
-      expect(FacterDB.database).to be_a String
+    after(:each) do
+      ENV.delete('FACTERDB_SEARCH_PATHS')
     end
 
-    it 'without internal paths' do
-      ENV['FACTERDB_SKIP_DEFAULTDB'] = 'true'
-      ENV['FACTERDB_SEARCH_PATHS'] = nil
-      expect(FacterDB.facterdb_fact_files).to eq([])
+    it 'returns the deduplicated combination of .default_fact_files and .external_fact_files' do
+      ENV['FACTERDB_SEARCH_PATHS'] = facts_24_path
+
+      expect(facterdb_fact_files.count).to eq(described_class.default_fact_files.count)
     end
 
-    describe :windows do
+    context 'with no loaded fact sets' do
       before(:each) do
-        stub_const("File::PATH_SEPARATOR", ";")
-        stub_const("File::ALT_SEPARATOR", '\\')
-        stub_const("File::SEPARATOR", '/')
-        allow(File).to receive(:directory?).and_return(true)
+        ENV['FACTERDB_SKIP_DEFAULTDB'] = '1'
+        ENV.delete('FACTERDB_SEARCH_PATHS')
       end
 
-      it '#external_fact_files with env variable and multiple paths' do
-        ENV['FACTERDB_SEARCH_PATHS'] = [File.join(project_dir, 'facts', '2.4').gsub('/', '\\'), File.join(project_dir, 'facts', '2.3').gsub('/', '\\')].join(File::PATH_SEPARATOR)
-        expect(FacterDB.external_fact_files.count).to be >= 150
+      it { is_expected.to be_empty }
+    end
+  end
+
+  describe '.database' do
+    subject(:database) { described_class.database }
+
+    before(:each) do
+      ENV.delete('FACTERDB_SKIP_DEFAULTDB')
+      ENV.delete('FACTERDB_SEARCH_PATHS')
+      FacterDB.instance_variable_set(:@database, nil)
+    end
+
+    it 'returns a String' do
+      expect(database).to be_an_instance_of(String)
+    end
+
+    it 'is parsable JSON' do
+      expect { JSON.parse(database) }.not_to raise_error
+    end
+
+    context 'when FACTERDB_INJECT_SOURCE environment variable is set' do
+      subject(:json_database) { JSON.parse(database) }
+
+      before(:each) do
+        ENV['FACTERDB_INJECT_SOURCE'] = '1'
       end
 
-      it '#external_fact_files with env variable' do
-        ENV['FACTERDB_SEARCH_PATHS'] = File.join(project_dir, 'facts', '2.4').gsub('/', '\\')
-        expect(FacterDB.external_fact_files.count).to be >= 50
+      it 'contains a "_facterdb_filename" key in each fact set' do
+        expect(json_database).to all(include('_facterdb_filename' => anything))
       end
 
-      it '#external_fact_files with argument' do
-        ENV['FACTERDB_SEARCH_PATHS'] = nil
-        path = File.join(project_dir, 'facts', '2.4').gsub('/', '\\')
-        expect(FacterDB.external_fact_files(path).count).to be >= 102
+      it 'contains a "_facterdb_path" key in each fact set' do
+        expect(json_database).to all(include('_facterdb_path' => anything))
       end
     end
   end
 
-  describe '#get_os_facts' do
-    context 'without parameters' do
-      subject { FacterDB.get_os_facts() }
-      it "Should return an array of hashes with at least 1 element" do
-        expect(subject.class).to eq Array
-        expect(subject.size).not_to eq(0)
-        expect(subject.select { |facts| facts.class != Hash }.size).to eq(0)
-      end
+  describe '.get_os_facts' do
+    subject(:result) { FacterDB.get_os_facts(facter_version, filter) }
+
+    before(:each) do
+      object = defined?(Warning) ? Warning : Kernel
+      allow(object).to receive(:warn).and_call_original
+      allow(object).to receive(:warn).with(a_string_matching(%r{`get_os_facts` is deprecated}))
     end
 
     context 'without parameters' do
-      subject { FacterDB.get_os_facts() }
-      it "Should return an array of hashes with at least 1 element" do
-        expect(subject.class).to eq Array
-        expect(subject.size).not_to eq(0)
-        expect(subject.select { |facts| facts.class != Hash }.size).to eq(0)
-      end
+      subject(:result) { FacterDB.get_os_facts() }
+
+      include_examples 'returns a result'
     end
 
-    context 'with an Array filter' do
-      subject { FacterDB.get_os_facts('*', [{:osfamily => 'Debian'}]) }
-      it "Should return an array of hashes with at least 1 element" do
-        expect(subject.class).to eq Array
-        expect(subject.size).not_to eq(0)
-        expect(subject.select { |facts| facts.class != Hash }.size).to eq(0)
+    context 'when matching all Facter versions' do
+      let(:facter_version) { '*' }
+
+      context 'with an Array filter' do
+        let(:filter) { [{ :osfamily => 'Debian' }] }
+
+        include_examples 'returns a result'
       end
-    end
 
-    context 'with a Hash filter' do
-      subject { FacterDB.get_os_facts('*', {:osfamily => 'Debian'}) }
-      it "Should return an array of hashes with at least 1 element" do
-        expect(subject.class).to eq Array
-        expect(subject.size).not_to eq(0)
-        expect(subject.select { |facts| facts.class != Hash }.size).to eq(0)
+      context 'with a Hash filter' do
+        let(:filter) { { :osfamily => 'Debian' } }
+
+        include_examples 'returns a result'
+      end
+
+      context 'with a String filter' do
+        let(:filter) { 'osfamily=Debian' }
+
+        include_examples 'returns a result'
+      end
+
+      context 'with a filter of an unsupported type' do
+        let(:filter) { true }
+
+        it 'raises an error' do
+          expect { result }.to raise_error(%r{filter must be either})
+        end
       end
     end
 
-    context 'with a String filter' do
-      subject { FacterDB.get_os_facts('*', 'osfamily=Debian') }
-      it "Should return an array of hashes with at least 1 element" do
-        expect(subject.class).to eq Array
-        expect(subject.size).not_to eq(0)
-        expect(subject.select { |facts| facts.class != Hash }.size).to eq(0)
+    context 'when matching a specific facter version' do
+      let(:facter_version) { '2.4.0' }
+
+      shared_examples 'returns only the specified version' do
+        it 'only includes fact sets for the specified version' do
+          expect(result).to all(include(:facterversion => match(%r{\A2\.4})))
+        end
+      end
+
+      context 'with an Array filter' do
+        let(:filter) { [{ :osfamily => 'Debian' }] }
+
+        include_examples 'returns a result'
+        include_examples 'returns only the specified version'
+      end
+
+      context 'with a Hash filter' do
+        let(:filter) { { :osfamily => 'Debian' } }
+
+        include_examples 'returns a result'
+        include_examples 'returns only the specified version'
+      end
+
+      context 'with a String filter' do
+        let(:filter) { 'osfamily=Debian' }
+
+        include_examples 'returns a result'
+        include_examples 'returns only the specified version'
+      end
+
+      context 'with a filter of an unsupported type' do
+        let(:filter) { true }
+
+        it 'raises an error' do
+          expect { result }.to raise_error(%r{filter must be either})
+        end
       end
     end
   end
 
-  describe '#get_facts' do
+  describe '.get_facts' do
+    subject(:result) { FacterDB.get_facts(filter) }
+
+    let(:filter) { nil }
+
     context 'without parameters' do
-      subject { FacterDB.get_facts() }
-      it "Should return an array of hashes with at least 1 element" do
-        expect(subject.class).to eq Array
-        expect(subject.size).not_to eq(0)
-        expect(subject.select { |facts| facts.class != Hash }.size).to eq(0)
-      end
+      include_examples "returns a result"
     end
 
     context 'with an Array filter' do
-      subject { FacterDB.get_facts([{:osfamily => 'Debian'}]) }
-      it "Should return an array of hashes with at least 1 element" do
-        expect(subject.class).to eq Array
-        expect(subject.size).not_to eq(0)
-        expect(subject.select { |facts| facts.class != Hash }.size).to eq(0)
-      end
+      let(:filter) { [:osfamily => 'Debian'] }
+
+      include_examples "returns a result"
     end
 
     context 'with a Hash filter' do
-      subject { FacterDB.get_facts({:osfamily => 'Debian'}) }
-      it "Should return an array of hashes with at least 1 element" do
-        expect(subject.class).to eq Array
-        expect(subject.size).not_to eq(0)
-        expect(subject.select { |facts| facts.class != Hash }.size).to eq(0)
-      end
+      let(:filter) { { :osfamily => 'Debian' } }
+
+      include_examples "returns a result"
     end
 
     context 'with a String filter' do
-      subject { FacterDB.get_facts('osfamily=Debian') }
-      it "Should return an array of hashes with at least 1 element" do
-        expect(subject.class).to eq Array
-        expect(subject.size).not_to eq(0)
-        expect(subject.select { |facts| facts.class != Hash }.size).to eq(0)
+      let(:filter) { 'osfamily=Debian' }
+
+      include_examples "returns a result"
+    end
+
+    context 'with a filter of an unsupported type' do
+      let(:filter) { true }
+
+      it 'raises an error' do
+        expect { result }.to raise_error(%r{filter must be either})
       end
     end
   end