facter 2.0.1.rc1-x86-mingw32

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

data/spec/unit/core/execution_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'facter/core/execution'
+
+describe Facter::Core::Execution do
+  subject { described_class}
+  let(:impl) { described_class.impl }
+
+  it "delegates #search_paths to the implementation" do
+    impl.expects(:search_paths)
+    subject.search_paths
+  end
+
+  it "delegates #which to the implementation" do
+    impl.expects(:which).with('waffles')
+    subject.which('waffles')
+  end
+
+  it "delegates #absolute_path? to the implementation" do
+    impl.expects(:absolute_path?).with('waffles', nil)
+    subject.absolute_path?('waffles')
+  end
+
+  it "delegates #absolute_path? with an optional platform to the implementation" do
+    impl.expects(:absolute_path?).with('waffles', :windows)
+    subject.absolute_path?('waffles', :windows)
+  end
+
+  it "delegates #expand_command to the implementation" do
+    impl.expects(:expand_command).with('waffles')
+    subject.expand_command('waffles')
+  end
+
+  it "delegates #exec to the implementation" do
+    impl.expects(:exec).with('waffles')
+    subject.exec('waffles')
+  end
+end

data/spec/unit/core/logging_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+require 'facter/core/logging'
+
+describe Facter::Core::Logging do
+
+  subject { described_class }
+
+  after(:all) do
+    subject.debugging(false)
+    subject.timing(false)
+  end
+
+  describe "emitting debug messages" do
+    it "doesn't log a message when debugging is disabled" do
+      subject.debugging(false)
+      subject.expects(:puts).never
+      subject.debug("foo")
+    end
+
+    describe "and debugging is enabled" do
+      before { subject.debugging(true) }
+      it "emits a warning when called with nil" do
+        subject.expects(:warn).with { |msg| expect(msg).to match /invalid message nil:NilClass/ }
+        subject.debug(nil)
+      end
+
+      it "emits a warning when called with an empty string" do
+        subject.expects(:warn).with { |msg| expect(msg).to match /invalid message "":String/ }
+        subject.debug("")
+      end
+
+      it "prints the message when logging is enabled" do
+        subject.expects(:puts).with { |msg| expect(msg).to match /foo/ }
+        subject.debug("foo")
+      end
+    end
+  end
+
+  describe "when warning" do
+    it "emits a warning when given a string" do
+      subject.debugging(true)
+      Kernel.expects(:warn).with('foo')
+      subject.warn('foo')
+    end
+
+    it "emits a warning regardless of log level" do
+      subject.debugging(false)
+      Kernel.expects(:warn).with "foo"
+      subject.warn "foo"
+    end
+
+    it "emits a warning if nil is passed" do
+      Kernel.expects(:warn).with { |msg| expect(msg).to match /invalid message nil:NilClass/ }
+      subject.warn(nil)
+    end
+
+    it "emits a warning if an empty string is passed" do
+      Kernel.expects(:warn).with { |msg| expect(msg).to match /invalid message "":String/ }
+      subject.warn('')
+    end
+  end
+
+  describe "when warning once" do
+    it "only logs a given warning string once" do
+      subject.expects(:warn).with('foo').once
+      subject.warnonce('foo')
+      subject.warnonce('foo')
+    end
+  end
+
+  describe "when setting the debugging mode" do
+    it "is enabled when the given value is true" do
+      subject.debugging(true)
+      expect(subject.debugging?).to be_true
+    end
+
+    it "is disabled when the given value is false" do
+      subject.debugging(false)
+      expect(subject.debugging?).to be_false
+    end
+
+    it "is disabled when the given value is nil" do
+      subject.debugging(nil)
+      expect(subject.debugging?).to be_false
+    end
+  end
+
+  describe "when setting the timing mode" do
+    it "is enabled when the given value is true" do
+      subject.timing(true)
+      expect(subject.timing?).to be_true
+    end
+
+    it "is disabled when the given value is false" do
+      subject.timing(false)
+      expect(subject.timing?).to be_false
+    end
+
+    it "is disabled when the given value is nil" do
+      subject.timing(nil)
+      expect(subject.timing?).to be_false
+    end
+  end
+end