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

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

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

@@ -1,42 +0,0 @@
-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 #execute" do
-    impl.expects(:execute).with('waffles', {:on_fail => nil})
-    subject.exec('waffles')
-  end
-
-  it "delegates #execute to the implementation" do
-    impl.expects(:execute).with('waffles', {})
-    subject.execute('waffles')
-  end
-end

data/spec/unit/core/logging_spec.rb

@@ -1,223 +0,0 @@
-require 'spec_helper'
-require 'facter/core/logging'
-
-describe Facter::Core::Logging do
-
-  subject { described_class }
-
-  after(:all) do
-    subject.debugging(false)
-    subject.timing(false)
-    subject.on_message
-  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
-
-  describe 'without a logging callback' do
-    before :each do
-      subject.timing(true)
-      subject.debugging(true)
-      subject.on_message
-    end
-
-    it 'calls puts for debug' do
-      subject.expects(:puts).with(subject::GREEN + 'foo' + subject::RESET).once
-      subject.debug('foo')
-    end
-
-    it 'calls puts for debugonce' do
-      subject.expects(:puts).with(subject::GREEN + 'foo' + subject::RESET).once
-      subject.debugonce('foo')
-      subject.debugonce('foo')
-    end
-
-    it 'calls Kernel.warn for warn' do
-      Kernel.expects(:warn).with('foo').once
-      subject.warn('foo')
-    end
-
-    it 'calls Kernel.warn for warnonce' do
-      Kernel.expects(:warn).with('foo').once
-      subject.warnonce('foo')
-      subject.warnonce('foo')
-    end
-
-    it 'calls $stderr.puts for timing' do
-      $stderr.expects(:puts).with(subject::GREEN + 'foo' + subject::RESET).once
-      subject.show_time('foo')
-    end
-  end
-
-  describe 'with a logging callback' do
-    before :each do
-      subject.debugging(true)
-      subject.timing(true)
-      subject.on_message
-    end
-
-    def log_message(level, message)
-      called = false
-      subject.on_message do |lvl, msg|
-        called = true
-        expect(lvl).to eq(level)
-        expect(msg).to eq(message)
-      end
-      case level
-      when :debug
-        Facter.debug(message)
-      when :warn
-        Facter.warn(message)
-      when :info
-        Facter.show_time(message)
-      else
-        raise 'unexpected logging level'
-      end
-      subject.on_message
-      expect(called).to be_true
-    end
-
-    def log_message_once(level, message)
-      calls = 0
-      subject.on_message do |lvl, msg|
-        expect(lvl).to eq(level)
-        expect(msg).to eq(message)
-        calls += 1
-      end
-      case level
-      when :debug
-        Facter.debugonce(message)
-        Facter.debugonce(message)
-      when :warn
-        Facter.warnonce(message)
-        Facter.warnonce(message)
-      else
-        raise 'unexpected logging level'
-      end
-      expect(calls).to eq(1)
-    end
-
-    it 'does not call puts for debug or debugonce' do
-      subject.on_message {}
-      subject.expects(:puts).never
-      subject.debug('debug message')
-      subject.debugonce('debug once message')
-    end
-
-    it 'passes debug messages to callback' do
-      log_message(:debug, 'debug message')
-      log_message_once(:debug, 'debug once message')
-    end
-
-    it 'does not call Kernel.warn for warn or warnonce' do
-      subject.on_message {}
-      Kernel.expects(:warn).never
-      subject.warn('warn message')
-      subject.warnonce('warn once message')
-    end
-
-    it 'passes warning messages to callback' do
-      log_message(:warn, 'warn message')
-      log_message_once(:warn, 'warn once message')
-    end
-
-    it 'does not call $stderr.puts for show_time' do
-      subject.on_message {}
-      $stderr.expects(:puts).never
-      subject.show_time('debug message')
-    end
-
-    it 'passes info messages to callback' do
-      log_message(:info, 'timing message')
-    end
-  end
-end

data/spec/unit/core/resolvable_spec.rb

@@ -1,81 +0,0 @@
-require 'spec_helper'
-require 'facter/core/resolvable'
-
-describe Facter::Core::Resolvable do
-
-  class ResolvableClass
-    def initialize(name)
-      @name = name
-      @fact = Facter::Util::Fact.new("stub fact")
-    end
-    attr_accessor :name, :resolve_value
-    attr_reader :fact
-    include Facter::Core::Resolvable
-  end
-
-  subject { ResolvableClass.new('resolvable') }
-
-  it "has a default timeout of 0 seconds" do
-    expect(subject.limit).to eq 0
-  end
-
-  it "can specify a custom timeout" do
-    subject.timeout = 10
-    expect(subject.limit).to eq 10
-  end
-
-  describe "generating a value" do
-    it "returns the results of #resolve_value" do
-      subject.resolve_value = 'stuff'
-      expect(subject.value).to eq 'stuff'
-    end
-
-    it "normalizes the resolved value" do
-      Facter::Util::Normalization.expects(:normalize).returns 'stuff'
-      subject.resolve_value = 'stuff'
-      expect(subject.value).to eq('stuff')
-    end
-
-    it "logs a warning if an exception was raised" do
-      subject.expects(:resolve_value).raises RuntimeError, "kaboom!"
-      Facter.expects(:warn).with(regexp_matches(/Could not retrieve .*: kaboom!/))
-      expect(subject.value).to eq nil
-    end
-  end
-
-  describe "timing out" do
-    it "uses #limit instead of #timeout to determine the timeout period" do
-      subject.expects(:timeout).never
-      subject.expects(:limit).returns 25
-
-      Timeout.expects(:timeout).with(25)
-      subject.value
-    end
-
-    it "returns nil if the timeout was reached" do
-      Facter.expects(:warn).with(regexp_matches(/Timed out after 0\.1 seconds while resolving/))
-      Timeout.expects(:timeout).raises Timeout::Error
-
-      subject.timeout = 0.1
-
-      expect(subject.value).to be_nil
-    end
-  end
-
-  describe 'callbacks when flushing facts' do
-    class FlushFakeError < StandardError; end
-
-    context '#on_flush' do
-      it 'accepts a block with on_flush' do
-        subject.on_flush() { raise NotImplementedError }
-      end
-    end
-
-    context '#flush' do
-      it 'calls the block passed to on_flush' do
-        subject.on_flush() { raise FlushFakeError }
-        expect { subject.flush }.to raise_error FlushFakeError
-      end
-    end
-  end
-end