facter 2.5.7-x64-mingw32 → 3.9.6.cfacter.20180412-x64-mingw32

data/spec/unit/blockdevices_spec.rb

@@ -1,109 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'spec_helper'
-require 'facter'
-require 'facter/util/nothing_loader'
-
-describe "Block device facts" do
-
-  describe "on non-Linux OS" do
-
-    it "should not exist when kernel isn't Linux" do
-      Facter.fact(:kernel).stubs(:value).returns("SunOS")
-      Facter.fact(:blockdevices).should == nil
-    end
-
-  end
-
-  describe "on Linux" do
-
-    describe "with /sys/block/" do
-
-      describe "with valid entries" do
-        before :each do
-          Facter::Util::Config.ext_fact_loader = Facter::Util::NothingLoader.new
-          Facter.fact(:kernel).stubs(:value).returns("Linux")
-          File.stubs(:exist?).with('/sys/block/').returns(true)
-
-          Dir.stubs(:entries).with("/sys/block/").returns([".", "..", "hda", "sda", "sdb"])
-
-          File.stubs(:exist?).with("/sys/block/./device").returns(false)
-          File.stubs(:exist?).with("/sys/block/../device").returns(false)
-
-          stubdevices = [
-            #device,    size,               vendor,     model
-            ["hda"],
-            ["sda",     "976773168",        "ATA",      "WDC WD5000AAKS-0"],
-            ["sdb",     "8787591168",       "DELL",     "PERC H700"]
-          ]
-
-          stubdevices.each do |device, size, vendor, model|
-            stubdir = "/sys/block/#{device}"
-            File.stubs(:exist?).with(stubdir + "/device").returns(true)
-            File.stubs(:exist?).with(stubdir + "/size").returns(size ? true : false)
-            File.stubs(:exist?).with(stubdir + "/device/model").returns(model ? true : false)
-            File.stubs(:exist?).with(stubdir + "/device/vendor").returns(vendor ? true : false)
-            IO.stubs(:read).with(stubdir + "/size").returns(size) if size
-            IO.stubs(:read).with(stubdir + "/device/vendor").returns(vendor) if vendor
-            IO.stubs(:read).with(stubdir + "/device/model").returns(model) if model
-          end
-        end
-
-        it "should report three block devices, hda, sda, and sdb, with accurate information from sda and sdb, and without invalid . or .. entries" do
-          Facter.fact(:blockdevices).value.should == "hda,sda,sdb"
-
-          # handle facts that should not exist
-          %w{ . .. hda }.each do |device|
-            Facter.fact("blockdevice_#{device}_size".to_sym).should == nil
-            Facter.fact("blockdevice_#{device}_vendor".to_sym).should == nil
-            Facter.fact("blockdevice_#{device}_model".to_sym).should == nil
-          end
-
-          # handle facts that should exist
-          %w{ sda sdb }.each do |device|
-            Facter.fact("blockdevice_#{device}_size".to_sym).should_not == nil
-            Facter.fact("blockdevice_#{device}_vendor".to_sym).should_not == nil
-            Facter.fact("blockdevice_#{device}_model".to_sym).should_not == nil
-          end
-
-          Facter.fact(:blockdevice_sda_model).value.should == "WDC WD5000AAKS-0"
-          Facter.fact(:blockdevice_sda_vendor).value.should == "ATA"
-          Facter.fact(:blockdevice_sda_size).value.should == 500107862016
-
-          Facter.fact(:blockdevice_sdb_model).value.should == "PERC H700"
-          Facter.fact(:blockdevice_sdb_vendor).value.should == "DELL"
-          Facter.fact(:blockdevice_sdb_size).value.should == 4499246678016
-
-        end
-
-      end
-      describe "with invalid entries in /sys/block" do
-        before :each do
-          Facter.fact(:kernel).stubs(:value).returns("Linux")
-          File.stubs(:exist?).with('/sys/block/').returns(true)
-
-          Dir.stubs(:entries).with("/sys/block/").returns([".", "..", "xda", "ydb"])
-
-          File.stubs(:exist?).with("/sys/block/./device").returns(false)
-          File.stubs(:exist?).with("/sys/block/../device").returns(false)
-          File.stubs(:exist?).with("/sys/block/xda/device").returns(false)
-          File.stubs(:exist?).with("/sys/block/ydb/device").returns(false)
-        end
-
-        it "should not exist with invalid entries in /sys/block" do
-          Facter.fact(:blockdevices).should == nil
-        end
-      end
-    end
-    describe "without /sys/block/" do
-
-      it "should not exist without /sys/block/ on Linux" do
-        Facter.fact(:kernel).stubs(:value).returns("Linux")
-        File.stubs(:exist?).with('/sys/block/').returns(false)
-        Facter.fact(:blockdevices).should == nil
-      end
-
-    end
-
-  end
-end

data/spec/unit/core/aggregate_spec.rb

@@ -1,125 +0,0 @@
-require 'spec_helper'
-require 'facter/core/aggregate'
-
-describe Facter::Core::Aggregate do
-
-  let(:fact) { stub('stub_fact', :name => 'stub_fact') }
-
-  subject { obj = described_class.new('aggregated', fact) }
-
-  it "can be resolved" do
-    expect(subject).to be_a_kind_of Facter::Core::Resolvable
-  end
-
-  it "can be confined and weighted" do
-    expect(subject).to be_a_kind_of Facter::Core::Suitable
-  end
-
-  describe "setting options" do
-
-    it "can set the timeout" do
-      subject.set_options(:timeout => 314)
-      expect(subject.limit).to eq 314
-    end
-
-    it "can set the weight" do
-      subject.set_options(:weight => 27)
-      expect(subject.weight).to eq 27
-    end
-
-    it "can set the name" do
-      subject.set_options(:name => 'something')
-      expect(subject.name).to eq 'something'
-    end
-
-    it "fails on unhandled options" do
-      expect do
-        subject.set_options(:foo => 'bar')
-      end.to raise_error(ArgumentError, /Invalid aggregate options .*foo/)
-    end
-  end
-
-  describe "declaring chunks" do
-    it "requires that an chunk is given a block" do
-      expect { subject.chunk(:fail) }.to raise_error(ArgumentError, /requires a block/)
-    end
-
-    it "allows an chunk to have a list of requirements" do
-      subject.chunk(:data, :require => [:other]) { }
-      expect(subject.deps[:data]).to eq [:other]
-    end
-
-    it "converts a single chunk requirement to an array" do
-      subject.chunk(:data, :require => :other) { }
-      expect(subject.deps[:data]).to eq [:other]
-    end
-
-    it "raises an error when an unhandled option is passed" do
-      expect {
-        subject.chunk(:data, :before => [:other]) { }
-      }.to raise_error(ArgumentError, /Unexpected options.*#chunk: .*before/)
-    end
-  end
-
-  describe "handling interactions between chunks" do
-    it "generates a warning when there is a dependency cycle in chunks" do
-      subject.chunk(:first, :require => [:second]) { }
-      subject.chunk(:second, :require => [:first]) { }
-
-      Facter.expects(:warn) do |msg|
-        expect(msg).to match /dependency cycles: .*[:first, :second]/
-      end
-
-      subject.value
-    end
-
-    it "passes all requested chunk results to the depending chunk" do
-      subject.chunk(:first) { ['foo'] }
-      subject.chunk(:second, :require => [:first]) do |first|
-        [first[0] + ' bar']
-      end
-
-      output = subject.value
-      expect(output).to include 'foo'
-      expect(output).to include 'foo bar'
-    end
-
-    it "clones and freezes chunk results passed to other chunks" do
-      subject.chunk(:first) { 'foo' }
-      subject.chunk(:second, :require => [:first]) do |first|
-        expect(first).to be_frozen
-      end
-
-      subject.aggregate do |chunks|
-        chunks.values.each do |chunk|
-          expect(chunk).to be_frozen
-        end
-      end
-    end
-  end
-
-  describe "aggregating chunks" do
-    it "passes all chunk results as a hash to the aggregate block" do
-      subject.chunk(:data) { 'data chunk' }
-      subject.chunk(:datum) { 'datum chunk' }
-
-      subject.aggregate do |chunks|
-        expect(chunks).to eq(:data => 'data chunk', :datum => 'datum chunk')
-      end
-
-      subject.value
-    end
-
-    it "uses the result of the aggregate block as the value" do
-      subject.aggregate { "who needs chunks anyways" }
-      expect(subject.value).to eq "who needs chunks anyways"
-    end
-  end
-
-  describe "evaluating" do
-    it "evaluates the block in the context of the aggregate" do
-      subject.expects(:has_weight).with(5)
-      subject.evaluate { has_weight(5) }
-    end
-  end
-end

data/spec/unit/core/directed_graph_spec.rb

@@ -1,79 +0,0 @@
-require 'spec_helper'
-require 'facter/core/directed_graph'
-
-describe Facter::Core::DirectedGraph do
-  subject(:graph) { described_class.new }
-
-  describe "detecting cycles" do
-    it "is acyclic if the graph is empty" do
-      expect(graph).to be_acyclic
-    end
-
-    it "is acyclic if the graph has no edges" do
-      graph[:one] = []
-      graph[:two] = []
-
-      expect(graph).to be_acyclic
-    end
-
-    it "is acyclic if a vertex has an edge to itself" do
-      graph[:one] = [:one]
-      expect(graph).to be_acyclic
-    end
-
-    it "is acyclic if there are no loops in the graph" do
-      graph[:one] = [:two, :three]
-      graph[:two] = [:four]
-      graph[:three] = [:four]
-      graph[:four] = []
-
-      expect(graph).to be_acyclic
-    end
-
-    it "is cyclic if there is a loop in the graph" do
-      graph[:one] = [:two]
-      graph[:two] = [:one]
-      expect(graph).to_not be_acyclic
-    end
-
-    it "can return the cycles in the graph" do
-      graph[:one] = [:two]
-      graph[:two] = [:one]
-
-      graph[:three] = [:four]
-      graph[:four] = [:three]
-
-      first_cycle = graph.cycles.find { |cycle| cycle.include? :one }
-      second_cycle = graph.cycles.find { |cycle| cycle.include? :three }
-
-      expect(first_cycle).to include :two
-      expect(second_cycle).to include :four
-    end
-  end
-
-  describe "sorting" do
-    it "returns the vertices in topologically sorted order" do
-      graph[:one] = [:two, :three]
-      graph[:two] = [:three]
-      graph[:three] = []
-      expect(graph.tsort).to eq [:three, :two, :one]
-    end
-
-    it "raises an error if there is a cycle in the graph" do
-      graph[:one] = [:two]
-      graph[:two] = [:one]
-
-      expect {
-        graph.tsort
-      }.to raise_error(Facter::Core::DirectedGraph::CycleError, /found the following cycles:/)
-    end
-
-    it "raises an error if there is an edge to a non-existent vertex" do
-      graph[:one] = [:two, :three]
-      graph[:two] = [:three]
-      expect {
-        graph.tsort
-      }.to raise_error(Facter::Core::DirectedGraph::MissingVertex, /missing elements.*three/)
-    end
-  end
-end

data/spec/unit/core/execution/base_spec.rb

@@ -1,130 +0,0 @@
-require 'spec_helper'
-require 'facter/core/execution'
-
-describe Facter::Core::Execution::Base do
-
-  describe "#with_env" do
-    it "should execute the caller's block with the specified env vars" do
-      test_env = { 'LANG' => 'C', 'LC_ALL' => 'C', 'FOO' => 'BAR' }
-      subject.with_env test_env do
-        test_env.keys.each do |key|
-          ENV[key].should == test_env[key]
-        end
-      end
-    end
-
-    it "should restore pre-existing environment variables to their previous values" do
-      orig_env = {}
-      new_env = {}
-      # an arbitrary sentinel value to use to temporarily set the environment vars to
-      sentinel_value = "Abracadabra"
-
-      # grab some values from the existing ENV (arbitrarily choosing 3 here)
-      ENV.keys.first(3).each do |key|
-        # save the original values so that we can test against them later
-        orig_env[key] = ENV[key]
-        # create bogus temp values for the chosen keys
-        new_env[key] = sentinel_value
-      end
-
-      # verify that, during the 'with_env', the new values are used
-      subject.with_env new_env do
-        orig_env.keys.each do |key|
-          ENV[key].should == new_env[key]
-        end
-      end
-
-      # verify that, after the 'with_env', the old values are restored
-      orig_env.keys.each do |key|
-        ENV[key].should == orig_env[key]
-      end
-    end
-
-    it "should not be affected by a 'return' statement in the yield block" do
-      @sentinel_var = :resolution_test_foo.to_s
-
-      # the intent of this test case is to test a yield block that contains a return statement.  However, it's illegal
-      # to use a return statement outside of a method, so we need to create one here to give scope to the 'return'
-      def handy_method()
-        ENV[@sentinel_var] = "foo"
-        new_env = { @sentinel_var => "bar" }
-
-        subject.with_env new_env do
-          ENV[@sentinel_var].should == "bar"
-          return
-        end
-      end
-
-      handy_method()
-
-      ENV[@sentinel_var].should == "foo"
-
-    end
-  end
-
-  describe "#execute" do
-
-    it "switches LANG and LC_ALL to C when executing the command" do
-      subject.expects(:with_env).with('LC_ALL' => 'C', 'LANG' => 'C')
-      subject.execute('foo')
-    end
-
-    it "expands the command before running it" do
-      subject.stubs(:`).returns ''
-      subject.expects(:expand_command).with('foo').returns '/bin/foo'
-      subject.execute('foo')
-    end
-
-    describe "and the command is not present" do
-      it "raises an error when the :on_fail behavior is :raise" do
-        subject.expects(:expand_command).with('foo').returns nil
-        expect { subject.execute('foo') }.to raise_error(Facter::Core::Execution::ExecutionFailure)
-      end
-
-      it "returns the given value when :on_fail is set to a value" do
-        subject.expects(:expand_command).with('foo').returns nil
-        expect(subject.execute('foo', :on_fail => nil)).to be_nil
-      end
-    end
-
-    describe "when command execution fails" do
-      before do
-        subject.expects(:`).with("/bin/foo").raises "kaboom!"
-        subject.expects(:expand_command).with('foo').returns '/bin/foo'
-      end
-
-      it "raises an error when the :on_fail behavior is :raise" do
-        expect { subject.execute('foo') }.to raise_error(Facter::Core::Execution::ExecutionFailure)
-      end
-
-      it "returns the given value when :on_fail is set to a value" do
-        expect(subject.execute('foo', :on_fail => nil)).to be_nil
-      end
-    end
-
-    it "launches a thread to wait on children if the command was interrupted" do
-      subject.expects(:`).with("/bin/foo").raises "kaboom!"
-      subject.expects(:expand_command).with('foo').returns '/bin/foo'
-
-      Facter.stubs(:warn)
-      Thread.expects(:new).yields
-      Process.expects(:waitall).once
-
-      subject.execute("foo", :on_fail => nil)
-    end
-
-    it "returns the output of the command" do
-      subject.expects(:`).with("/bin/foo").returns 'hi'
-      subject.expects(:expand_command).with('foo').returns '/bin/foo'
-
-      expect(subject.execute("foo")).to eq 'hi'
-    end
-
-    it "strips off trailing newlines" do
-      subject.expects(:`).with("/bin/foo").returns "hi\n"
-      subject.expects(:expand_command).with('foo').returns '/bin/foo'
-
-      expect(subject.execute("foo")).to eq 'hi'
-    end
-  end
-end

data/spec/unit/core/execution/posix_spec.rb

@@ -1,96 +0,0 @@
-require 'spec_helper'
-require 'facter/util/config'
-
-describe Facter::Core::Execution::Posix, :unless => Facter::Util::Config.is_windows? do
-  describe "#search_paths" do
-    it "should use the PATH environment variable plus /sbin and /usr/sbin on unix" do
-      ENV.expects(:[]).with('PATH').returns "/bin:/usr/bin"
-      subject.search_paths.should == %w{/bin /usr/bin /sbin /usr/sbin}
-    end
-  end
-
-  describe "#which" do
-    before :each do
-      subject.stubs(:search_paths).returns [ '/bin', '/sbin', '/usr/sbin']
-    end
-
-    context "and provided with an absolute path" do
-      it "should return the binary if executable" do
-        File.expects(:file?).with('/opt/foo').returns true
-        File.expects(:executable?).with('/opt/foo').returns true
-        subject.which('/opt/foo').should == '/opt/foo'
-      end
-
-      it "should return nil if the binary is not executable" do
-        File.expects(:executable?).with('/opt/foo').returns false
-        subject.which('/opt/foo').should be_nil
-      end
-
-      it "should return nil if the binary is not a file" do
-        File.expects(:file?).with('/opt/foo').returns false
-        File.expects(:executable?).with('/opt/foo').returns true
-        subject.which('/opt/foo').should be_nil
-      end
-    end
-
-    context "and not provided with an absolute path" do
-      it "should return the absolute path if found" do
-        File.expects(:file?).with('/bin/foo').never
-        File.expects(:executable?).with('/bin/foo').returns false
-        File.expects(:file?).with('/sbin/foo').returns true
-        File.expects(:executable?).with('/sbin/foo').returns true
-        File.expects(:file?).with('/usr/sbin/foo').never
-        File.expects(:executable?).with('/usr/sbin/foo').never
-        subject.which('foo').should == '/sbin/foo'
-      end
-
-      it "should return nil if not found" do
-        File.expects(:executable?).with('/bin/foo').returns false
-        File.expects(:executable?).with('/sbin/foo').returns false
-        File.expects(:executable?).with('/usr/sbin/foo').returns false
-        subject.which('foo').should be_nil
-      end
-    end
-  end
-
-  describe "#expand_command" do
-    it "should expand binary" do
-      subject.expects(:which).with('foo').returns '/bin/foo'
-      subject.expand_command('foo -a | stuff >> /dev/null').should == '/bin/foo -a | stuff >> /dev/null'
-    end
-
-    it "should expand double quoted binary" do
-      subject.expects(:which).with('/tmp/my foo').returns '/tmp/my foo'
-      subject.expand_command(%q{"/tmp/my foo" bar}).should == %q{'/tmp/my foo' bar}
-    end
-
-    it "should expand single quoted binary" do
-      subject.expects(:which).with('my foo').returns '/home/bob/my path/my foo'
-      subject.expand_command(%q{'my foo' -a}).should == %q{'/home/bob/my path/my foo' -a}
-    end
-
-    it "should quote expanded binary if found in path with spaces" do
-      subject.expects(:which).with('foo.sh').returns '/home/bob/my tools/foo.sh'
-      subject.expand_command('foo.sh /a /b').should == %q{'/home/bob/my tools/foo.sh' /a /b}
-    end
-
-    it "should return nil if not found" do
-      subject.expects(:which).with('foo').returns nil
-      subject.expand_command('foo -a | stuff >> /dev/null').should be_nil
-    end
-  end
-
-  describe "#absolute_path?" do
-    %w[/ /foo /foo/../bar //foo //Server/Foo/Bar //?/C:/foo/bar /\Server/Foo /foo//bar/baz].each do |path|
-      it "should return true for #{path}" do
-        subject.should be_absolute_path(path)
-      end
-    end
-
-    %w[. ./foo \foo C:/foo \\Server\Foo\Bar \\?\C:\foo\bar \/?/foo\bar \/Server/foo foo//bar/baz].each do |path|
-      it "should return false for #{path}" do
-        subject.should_not be_absolute_path(path)
-      end
-    end
-  end
-end