puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

data/spec/integration/util/windows/user_spec.rb

@@ -10,23 +10,23 @@ describe "Puppet::Util::Windows::User", :if => Puppet.features.microsoft_windows
 
     it "should be an admin if user's token contains the Administrators SID" do
       Puppet::Util::Windows::User.expects(:check_token_membership).returns(true)
-      Win32::Security.expects(:elevated_security?).never
+      Puppet::Util::Windows::Process.expects(:elevated_security?).never
 
       Puppet::Util::Windows::User.should be_admin
     end
 
     it "should not be an admin if user's token doesn't contain the Administrators SID" do
       Puppet::Util::Windows::User.expects(:check_token_membership).returns(false)
-      Win32::Security.expects(:elevated_security?).never
+      Puppet::Util::Windows::Process.expects(:elevated_security?).never
 
       Puppet::Util::Windows::User.should_not be_admin
     end
 
     it "should raise an exception if we can't check token membership" do
-      Puppet::Util::Windows::User.expects(:check_token_membership).raises(Win32::Security::Error, "Access denied.")
-      Win32::Security.expects(:elevated_security?).never
+      Puppet::Util::Windows::User.expects(:check_token_membership).raises(Puppet::Util::Windows::Error, "Access denied.")
+      Puppet::Util::Windows::Process.expects(:elevated_security?).never
 
-      lambda { Puppet::Util::Windows::User.admin? }.should raise_error(Win32::Security::Error, /Access denied./)
+      lambda { Puppet::Util::Windows::User.admin? }.should raise_error(Puppet::Util::Windows::Error, /Access denied./)
     end
   end
 
@@ -36,24 +36,90 @@ describe "Puppet::Util::Windows::User", :if => Puppet.features.microsoft_windows
     end
 
     it "should be an admin if user is running with elevated privileges" do
-      Win32::Security.stubs(:elevated_security?).returns(true)
+      Puppet::Util::Windows::Process.stubs(:elevated_security?).returns(true)
       Puppet::Util::Windows::User.expects(:check_token_membership).never
 
       Puppet::Util::Windows::User.should be_admin
     end
 
     it "should not be an admin if user is not running with elevated privileges" do
-      Win32::Security.stubs(:elevated_security?).returns(false)
+      Puppet::Util::Windows::Process.stubs(:elevated_security?).returns(false)
       Puppet::Util::Windows::User.expects(:check_token_membership).never
 
       Puppet::Util::Windows::User.should_not be_admin
     end
 
     it "should raise an exception if the process fails to open the process token" do
-      Win32::Security.stubs(:elevated_security?).raises(Win32::Security::Error, "Access denied.")
+      Puppet::Util::Windows::Process.stubs(:elevated_security?).raises(Puppet::Util::Windows::Error, "Access denied.")
       Puppet::Util::Windows::User.expects(:check_token_membership).never
 
-      lambda { Puppet::Util::Windows::User.admin? }.should raise_error(Win32::Security::Error, /Access denied./)
+      lambda { Puppet::Util::Windows::User.admin? }.should raise_error(Puppet::Util::Windows::Error, /Access denied./)
+    end
+  end
+
+  describe "module function" do
+    let(:username) { 'fabio' }
+    let(:bad_password) { 'goldilocks' }
+    let(:logon_fail_msg) { /Failed to logon user "fabio":  Logon failure: unknown user name or bad password./ }
+
+    def expect_logon_failure_error(&block)
+      expect {
+        yield
+      }.to raise_error { |error|
+        expect(error).to be_a(Puppet::Util::Windows::Error)
+        # http://msdn.microsoft.com/en-us/library/windows/desktop/ms681385(v=vs.85).aspx
+        # ERROR_LOGON_FAILURE 1326
+        expect(error.code).to eq(1326)
+      }
+    end
+
+    describe "load_profile" do
+      it "should raise an error when provided with an incorrect username and password" do
+        expect_logon_failure_error {
+          Puppet::Util::Windows::User.load_profile(username, bad_password)
+        }
+      end
+
+      it "should raise an error when provided with an incorrect username and nil password" do
+        expect_logon_failure_error {
+          Puppet::Util::Windows::User.load_profile(username, nil)
+        }
+      end
+    end
+
+    describe "logon_user" do
+      it "should raise an error when provided with an incorrect username and password" do
+        expect_logon_failure_error {
+          Puppet::Util::Windows::User.logon_user(username, bad_password)
+        }
+      end
+
+      it "should raise an error when provided with an incorrect username and nil password" do
+        expect_logon_failure_error {
+          Puppet::Util::Windows::User.logon_user(username, nil)
+        }
+      end
+    end
+
+    describe "password_is?" do
+      it "should return false given an incorrect username and password" do
+        Puppet::Util::Windows::User.password_is?(username, bad_password).should be_false
+      end
+
+      it "should return false given an incorrect username and nil password" do
+        Puppet::Util::Windows::User.password_is?(username, nil).should be_false
+      end
+
+      it "should return false given a nil username and an incorrect password" do
+        Puppet::Util::Windows::User.password_is?(nil, bad_password).should be_false
+      end
+    end
+
+    describe "check_token_membership" do
+      it "should not raise an error" do
+        # added just to call an FFI code path on all platforms
+        lambda { Puppet::Util::Windows::User.check_token_membership }.should_not raise_error
+      end
     end
   end
 end

data/spec/integration/util_spec.rb

@@ -36,7 +36,7 @@ describe Puppet::Util do
 
       admins = 'S-1-5-32-544'
       dacl = Puppet::Util::Windows::AccessControlList.new
-      dacl.allow(admins, Windows::File::FILE_ALL_ACCESS)
+      dacl.allow(admins, Puppet::Util::Windows::File::FILE_ALL_ACCESS)
       protect = true
       expected_sd = Puppet::Util::Windows::SecurityDescriptor.new(admins, admins, dacl, protect)
       Puppet::Util::Windows::Security.set_security_descriptor(file, expected_sd)
@@ -45,7 +45,7 @@ describe Puppet::Util do
       Puppet::Util.replace_file(file, ignored_mode) do |temp_file|
         ignored_sd = Puppet::Util::Windows::Security.get_security_descriptor(temp_file.path)
         users = 'S-1-5-11'
-        ignored_sd.dacl.allow(users, Windows::File::FILE_GENERIC_READ)
+        ignored_sd.dacl.allow(users, Puppet::Util::Windows::File::FILE_GENERIC_READ)
         Puppet::Util::Windows::Security.set_security_descriptor(temp_file.path, ignored_sd)
       end
 

data/spec/lib/matchers/resource.rb

@@ -64,4 +64,5 @@ module Matchers; module Resource
       @mismatch.empty? ? @matcher.failure_message_for_should : @mismatch
     end
   end
+  module_function :have_resource
 end; end

data/spec/lib/puppet_spec/compiler.rb

@@ -1,7 +1,10 @@
 module PuppetSpec::Compiler
+  module_function
+
   def compile_to_catalog(string, node = Puppet::Node.new('foonode'))
     Puppet[:code] = string
-    Puppet::Parser::Compiler.compile(node)
+    # see lib/puppet/indirector/catalog/compiler.rb#filter
+    Puppet::Parser::Compiler.compile(node).filter { |r| r.virtual? }
   end
 
   def compile_to_ral(manifest)
@@ -19,7 +22,11 @@ module PuppetSpec::Compiler
   end
 
   def apply_compiled_manifest(manifest, prioritizer = Puppet::Graph::SequentialPrioritizer.new)
-    transaction = Puppet::Transaction.new(compile_to_ral(manifest),
+    catalog = compile_to_ral(manifest)
+    if block_given?
+      catalog.resources.each { |res| yield res }
+    end
+    transaction = Puppet::Transaction.new(catalog,
                                          Puppet::Transaction::Report.new("apply"),
                                          prioritizer)
     transaction.evaluate
@@ -28,6 +35,12 @@ module PuppetSpec::Compiler
     transaction
   end
 
+  def apply_with_error_check(manifest)
+    apply_compiled_manifest(manifest) do |res|
+      res.expects(:err).never
+    end
+  end
+
   def order_resources_traversed_in(relationships)
     order_seen = []
     relationships.traverse { |resource| order_seen << resource.ref }

data/spec/lib/puppet_spec/files.rb

@@ -75,4 +75,14 @@ module PuppetSpec::Files
     $global_tempfiles ||= []
     $global_tempfiles << tmp
   end
+
+  def expect_file_mode(file, mode)
+    actual_mode = "%o" % Puppet::FileSystem.stat(file).mode
+    target_mode = if Puppet.features.microsoft_windows?
+      mode
+    else
+      "10" + "%04i" % mode.to_i
+    end
+    actual_mode.should == target_mode
+  end
 end

data/spec/lib/puppet_spec/language.rb

@@ -0,0 +1,74 @@
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+module PuppetSpec::Language
+  extend RSpec::Matchers::DSL
+
+  def produces(expectations)
+    calledFrom = caller
+    expectations.each do |manifest, resources|
+      it "evaluates #{manifest} to produce #{resources}" do
+        begin
+        case resources
+        when String
+          node = Puppet::Node.new('specification')
+          Puppet[:code] = manifest
+          compiler = Puppet::Parser::Compiler.new(node)
+          evaluator = Puppet::Pops::Parser::EvaluatingParser.new()
+
+          # see lib/puppet/indirector/catalog/compiler.rb#filter
+          catalog = compiler.compile.filter { |r| r.virtual? }
+
+          compiler.send(:instance_variable_set, :@catalog, catalog)
+
+          expect(evaluator.evaluate_string(compiler.topscope, resources)).to eq(true)
+        when Array
+          catalog = PuppetSpec::Compiler.compile_to_catalog(manifest)
+
+          if resources.empty?
+            base_resources = ["Class[Settings]", "Class[main]", "Stage[main]"]
+            expect(catalog.resources.collect(&:ref) - base_resources).to eq([])
+          else
+            resources.each do |reference|
+              if reference.is_a?(Array)
+                matcher = Matchers::Resource.have_resource(reference[0])
+                reference[1].each do |name, value|
+                  matcher = matcher.with_parameter(name, value)
+                end
+              else
+                matcher = Matchers::Resource.have_resource(reference)
+              end
+
+              expect(catalog).to matcher
+            end
+          end
+        else
+          raise "Unsupported creates specification: #{resources.inspect}"
+        end
+      rescue  Puppet::Error, RSpec::Expectations::ExpectationNotMetError => e
+        # provide the backtrace from the caller, or it is close to impossible to find some originators
+        e.set_backtrace(calledFrom)
+        raise
+      end
+
+      end
+    end
+  end
+
+  def fails(expectations)
+    calledFrom = caller
+    expectations.each do |manifest, pattern|
+      it "fails to evaluate #{manifest} with message #{pattern}" do
+        begin
+        expect do
+          PuppetSpec::Compiler.compile_to_catalog(manifest)
+        end.to raise_error(Puppet::Error, pattern)
+        rescue  RSpec::Expectations::ExpectationNotMetError => e
+          # provide the backgrace from the caller, or it is close to impossible to find some originators
+          e.set_backtrace(calledFrom)
+          raise
+        end
+      end
+    end
+  end
+end

data/spec/lib/puppet_spec/matchers.rb

@@ -44,63 +44,82 @@ RSpec::Matchers.define :exit_with do |expected|
   end
 end
 
-class HavePrintedMatcher
-  attr_accessor :expected, :actual
 
-  def initialize(expected)
-    case expected
+RSpec::Matchers.define :have_printed do |expected|
+
+  case expected
     when String, Regexp
-      @expected = expected
+      expected = expected
     else
-      @expected = expected.to_s
+      expected = expected.to_s
+  end
+
+  chain :and_exit_with do |code|
+    @expected_exit_code = code
+  end
+
+  define_method :matches_exit_code? do |actual|
+    @expected_exit_code.nil? || @expected_exit_code == actual
+  end
+
+  define_method :matches_output? do |actual|
+    return false unless actual
+    case expected
+      when String
+        actual.include?(expected)
+      when Regexp
+        expected.match(actual)
+      else
+        raise ArgumentError, "No idea how to match a #{actual.class.name}"
     end
   end
 
-  def matches?(block)
+  match do |block|
+    $stderr = $stdout = StringIO.new
+    $stdout.set_encoding('UTF-8') if $stdout.respond_to?(:set_encoding)
+
     begin
-      $stderr = $stdout = StringIO.new
-      $stdout.set_encoding('UTF-8') if $stdout.respond_to?(:set_encoding)
       block.call
+    rescue SystemExit => e
+      raise unless @expected_exit_code
+      @actual_exit_code = e.status
+    ensure
       $stdout.rewind
       @actual = $stdout.read
-    ensure
+
       $stdout = STDOUT
       $stderr = STDERR
     end
 
-    if @actual then
-      case @expected
-      when String
-        @actual.include? @expected
-      when Regexp
-        @expected.match @actual
-      end
-    else
-      false
-    end
+    matches_output?(@actual) && matches_exit_code?(@actual_exit_code)
   end
 
-  def failure_message_for_should
-    if @actual.nil? then
-      "expected #{@expected.inspect}, but nothing was printed"
+  failure_message_for_should do |actual|
+    if actual.nil? then
+      "expected #{expected.inspect}, but nothing was printed"
     else
-      "expected #{@expected.inspect} to be printed; got:\n#{@actual}"
+      if !@expected_exit_code.nil? && matches_output?(actual)
+        "expected exit with code #{@expected_exit_code} but " +
+          (@actual_exit_code.nil? ? " exit was not called" : "exited with #{@actual_exit_code} instead")
+      else
+        "expected #{expected.inspect} to be printed; got:\n#{actual}"
+      end
     end
   end
 
-  def failure_message_for_should_not
-    "expected #{@expected.inspect} to not be printed; got:\n#{@actual}"
+  failure_message_for_should_not do |actual|
+    if @expected_exit_code && matches_exit_code?(@actual_exit_code)
+      "expected exit code to not be #{@actual_exit_code}"
+    else
+      "expected #{expected.inspect} to not be printed; got:\n#{actual}"
+    end
   end
 
-  def description
-    "expect #{@expected.inspect} to be printed"
+  description do
+    "expect #{expected.inspect} to be printed" + (@expected_exit_code.nil ? '' : " with exit code #{@expected_exit_code}")
   end
 end
 
-def have_printed(what)
-  HavePrintedMatcher.new(what)
-end
-
 RSpec::Matchers.define :equal_attributes_of do |expected|
   match do |actual|
     actual.instance_variables.all? do |attr|
@@ -109,6 +128,14 @@ RSpec::Matchers.define :equal_attributes_of do |expected|
   end
 end
 
+RSpec::Matchers.define :equal_resource_attributes_of do |expected|
+  match do |actual|
+    actual.keys do |attr|
+      actual[attr] == expected[attr]
+    end
+  end
+end
+
 RSpec::Matchers.define :be_one_of do |*expected|
   match do |actual|
     expected.include? actual

data/spec/lib/puppet_spec/module_tool/stub_source.rb

@@ -100,6 +100,9 @@ module PuppetSpec
             "0.0.2" => { "pmtacceptance/stdlib" => ">= 2.2.0", "pmtacceptance/mysql" => ">= 0.0.1" },
             "0.0.1" => { "pmtacceptance/stdlib" => ">= 2.2.0" },
           },
+          'puppetlabs-oneversion' => {
+            "0.0.1" => {}
+          }
         }
 
         @available_releases.each do |name, versions|

data/spec/shared_behaviours/hiera_indirections.rb

@@ -0,0 +1,99 @@
+shared_examples_for "Hiera indirection" do |test_klass, fixture_dir|
+  include PuppetSpec::Files
+
+  def write_hiera_config(config_file, datadir)
+    File.open(config_file, 'w') do |f|
+      f.write("---
+        :yaml:
+          :datadir: #{datadir}
+        :hierarchy: ['global', 'invalid']
+        :logger: 'noop'
+        :backends: ['yaml']
+      ")
+    end
+  end
+
+  def request(key)
+    Puppet::Indirector::Request.new(:hiera, :find, key, nil)
+  end
+
+  before do
+    hiera_config_file = tmpfile("hiera.yaml")
+    Puppet.settings[:hiera_config] = hiera_config_file
+    write_hiera_config(hiera_config_file, fixture_dir)
+  end
+
+  after do
+    test_klass.instance_variable_set(:@hiera, nil)
+  end
+
+  it "should be the default data_binding terminus" do
+    Puppet.settings[:data_binding_terminus].should == :hiera
+  end
+
+  it "should raise an error if we don't have the hiera feature" do
+    Puppet.features.expects(:hiera?).returns(false)
+    lambda { test_klass.new }.should raise_error RuntimeError,
+      "Hiera terminus not supported without hiera library"
+  end
+
+  describe "the behavior of the hiera_config method", :if => Puppet.features.hiera? do
+    it "should override the logger and set it to puppet" do
+      test_klass.hiera_config[:logger].should == "puppet"
+    end
+
+    context "when the Hiera configuration file does not exist" do
+      let(:path) { File.expand_path('/doesnotexist') }
+
+      before do
+        Puppet.settings[:hiera_config] = path
+      end
+
+      it "should log a warning" do
+        Puppet.expects(:warning).with(
+         "Config file #{path} not found, using Hiera defaults")
+        test_klass.hiera_config
+      end
+
+      it "should only configure the logger and set it to puppet" do
+        Puppet.expects(:warning).with(
+         "Config file #{path} not found, using Hiera defaults")
+        test_klass.hiera_config.should == { :logger => 'puppet' }
+      end
+    end
+  end
+
+  describe "the behavior of the find method", :if => Puppet.features.hiera? do
+
+    let(:data_binder) { test_klass.new }
+
+    it "should support looking up an integer" do
+      data_binder.find(request("integer")).should == 3000
+    end
+
+    it "should support looking up a string" do
+      data_binder.find(request("string")).should == 'apache'
+    end
+
+    it "should support looking up an array" do
+      data_binder.find(request("array")).should == [
+        '0.ntp.puppetlabs.com',
+        '1.ntp.puppetlabs.com',
+      ]
+    end
+
+    it "should support looking up a hash" do
+      data_binder.find(request("hash")).should == {
+        'user'  => 'Hightower',
+        'group' => 'admin',
+        'mode'  => '0644'
+      }
+    end
+
+    it "raises a data binding error if hiera cannot parse the yaml data" do
+      expect do
+        data_binder.find(request('invalid'))
+      end.to raise_error(Puppet::DataBinding::LookupError)
+    end
+  end
+end