facter 1.7.6 → 2.0.1.rc1

data/spec/unit/core/aggregate_spec.rb

@@ -0,0 +1,125 @@
+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

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1,119 @@
+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", "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 "#exec" do
+
+    it "switches LANG to C when executing the command" do
+      subject.expects(:with_env).with('LANG' => 'C')
+      subject.exec('foo')
+    end
+
+    it "switches LC_ALL to C when executing the command"
+
+    it "expands the command before running it" do
+      subject.stubs(:`).returns ''
+      subject.expects(:expand_command).with('foo').returns '/bin/foo'
+      subject.exec('foo')
+    end
+
+    it "returns an empty string when the command could not be expanded" do
+      subject.expects(:expand_command).with('foo').returns nil
+      expect(subject.exec('foo')).to be_empty
+    end
+
+    it "logs a warning and returns an empty string when the command execution fails" do
+      subject.expects(:`).with("/bin/foo").raises "kaboom!"
+      Facter.expects(:warn).with("kaboom!")
+
+      subject.expects(:expand_command).with('foo').returns '/bin/foo'
+
+      expect(subject.exec("foo")).to be_empty
+    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.exec("foo")
+    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.exec("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.exec("foo")).to eq 'hi'
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe Facter::Core::Execution::Posix, :as_plaform => :posix 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(: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
+    end
+
+    context "and not provided with an absolute path" do
+      it "should return the absolute path if found" do
+        File.expects(:executable?).with('/bin/foo').returns false
+        File.expects(:executable?).with('/sbin/foo').returns true
+        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

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

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe Facter::Core::Execution::Windows, :as_platform => :windows do
+
+  describe "#search_paths" do
+    it "should use the PATH environment variable to determine locations" do
+      ENV.expects(:[]).with('PATH').returns 'C:\Windows;C:\Windows\System32'
+      subject.search_paths.should == %w{C:\Windows C:\Windows\System32}
+    end
+  end
+
+  describe "#which" do
+    before :each do
+      subject.stubs(:search_paths).returns ['C:\Windows\system32', 'C:\Windows', 'C:\Windows\System32\Wbem' ]
+      ENV.stubs(:[]).with('PATHEXT').returns nil
+    end
+
+    context "and provided with an absolute path" do
+      it "should return the binary if executable" do
+        File.expects(:executable?).with('C:\Tools\foo.exe').returns true
+        File.expects(:executable?).with('\\\\remote\dir\foo.exe').returns true
+        subject.which('C:\Tools\foo.exe').should == 'C:\Tools\foo.exe'
+        subject.which('\\\\remote\dir\foo.exe').should == '\\\\remote\dir\foo.exe'
+      end
+
+      it "should return nil if the binary is not executable" do
+        File.expects(:executable?).with('C:\Tools\foo.exe').returns false
+        File.expects(:executable?).with('\\\\remote\dir\foo.exe').returns false
+        subject.which('C:\Tools\foo.exe').should be_nil
+        subject.which('\\\\remote\dir\foo.exe').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(:executable?).with('C:\Windows\system32\foo.exe').returns false
+        File.expects(:executable?).with('C:\Windows\foo.exe').returns true
+        File.expects(:executable?).with('C:\Windows\System32\Wbem\foo.exe').never
+        subject.which('foo.exe').should == 'C:\Windows\foo.exe'
+      end
+
+      it "should return the absolute path with file extension if found" do
+        ['.COM', '.EXE', '.BAT', '.CMD', '' ].each do |ext|
+          File.stubs(:executable?).with('C:\Windows\system32\foo'+ext).returns false
+          File.stubs(:executable?).with('C:\Windows\System32\Wbem\foo'+ext).returns false
+        end
+        ['.COM', '.BAT', '.CMD', '' ].each do |ext|
+          File.stubs(:executable?).with('C:\Windows\foo'+ext).returns false
+        end
+        File.stubs(:executable?).with('C:\Windows\foo.EXE').returns true
+
+        subject.which('foo').should == 'C:\Windows\foo.EXE'
+      end
+
+      it "should return nil if not found" do
+        File.expects(:executable?).with('C:\Windows\system32\foo.exe').returns false
+        File.expects(:executable?).with('C:\Windows\foo.exe').returns false
+        File.expects(:executable?).with('C:\Windows\System32\Wbem\foo.exe').returns false
+        subject.which('foo.exe').should be_nil
+      end
+    end
+  end
+
+  describe "#expand_command" do
+    it "should expand binary" do
+      subject.expects(:which).with('cmd').returns 'C:\Windows\System32\cmd'
+      subject.expand_command(
+        'cmd /c echo foo > C:\bar'
+      ).should == 'C:\Windows\System32\cmd /c echo foo > C:\bar'
+    end
+
+    it "should expand double quoted binary" do
+      subject.expects(:which).with('my foo').returns 'C:\My Tools\my foo.exe'
+      subject.expand_command('"my foo" /a /b').should == '"C:\My Tools\my foo.exe" /a /b'
+    end
+
+    it "should not expand single quoted binary" do
+      subject.expects(:which).with('\'C:\My').returns nil
+      subject.expand_command('\'C:\My Tools\foo.exe\' /a /b').should be_nil
+    end
+
+    it "should quote expanded binary if found in path with spaces" do
+      subject.expects(:which).with('foo').returns 'C:\My Tools\foo.exe'
+      subject.expand_command('foo /a /b').should == '"C:\My Tools\foo.exe" /a /b'
+    end
+
+    it "should return nil if not found" do
+      subject.expects(:which).with('foo').returns nil
+      subject.expand_command('foo /a | stuff >> NUL').should be_nil
+    end
+  end
+
+  describe "#absolute_path?" do
+    %w[C:/foo C:\foo \\\\Server\Foo\Bar \\\\?\C:\foo\bar //Server/Foo/Bar //?/C:/foo/bar /\?\C:/foo\bar \/Server\Foo/Bar c:/foo//bar//baz].each do |path|
+      it "should return true for #{path}" do
+        subject.should be_absolute_path(path)
+      end
+    end
+
+    %w[/ . ./foo \foo /foo /foo/../bar //foo C:foo/bar foo//bar/baz].each do |path|
+      it "should return false for #{path}" do
+        subject.should_not be_absolute_path(path)
+      end
+    end
+  end
+end