puppet 3.4.3 → 3.5.0.rc1

data/spec/integration/type/nagios_spec.rb

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+require 'puppet/file_bucket/dipper'
+
+describe "Nagios file creation" do
+  include PuppetSpec::Files
+
+  before :each do
+    FileUtils.touch(target_file)
+    File.chmod(0600, target_file)
+    Puppet::FileBucket::Dipper.any_instance.stubs(:backup) # Don't backup to filebucket
+  end
+
+  let :target_file do
+    tmpfile('nagios_integration_specs')
+  end
+
+  # Copied from the crontab integration spec.
+  #
+  # @todo This should probably live in the PuppetSpec module instead then.
+  def run_in_catalog(*resources)
+    catalog = Puppet::Resource::Catalog.new
+    catalog.host_config = false
+    resources.each do |resource|
+      resource.expects(:err).never
+      catalog.add_resource(resource)
+    end
+
+    # the resources are not properly contained and generated resources
+    # will end up with dangling edges without this stubbing:
+    catalog.stubs(:container_of).returns resources[0]
+    catalog.apply
+  end
+
+  # These three helpers are from file_spec.rb
+  #
+  # @todo Define those centrally as well?
+  def get_mode(file)
+    Puppet::FileSystem.stat(file).mode
+  end
+
+  context "when creating a nagios config file" do
+    context "which is not managed" do
+      it "should choose the file mode if requested" do
+        resource = Puppet::Type.type(:nagios_host).new(
+          :name   => 'spechost',
+          :use    => 'spectemplate',
+          :ensure => 'present',
+          :target => target_file,
+          :mode   => '0640'
+        )
+        run_in_catalog(resource)
+        # sticky bit only applies to directories in Windows
+        mode = Puppet.features.microsoft_windows? ? "640" : "100640"
+        ( "%o" % get_mode(target_file) ).should == mode
+      end
+    end
+
+    context "which is managed" do
+      it "should not the mode" do
+        file_res = Puppet::Type.type(:file).new(
+          :name   => target_file,
+          :ensure => :present
+        )
+        nag_res = Puppet::Type.type(:nagios_host).new(
+          :name   => 'spechost',
+          :use    => 'spectemplate',
+          :ensure => :present,
+          :target => target_file,
+          :mode   => '0640'
+        )
+        run_in_catalog(file_res, nag_res)
+        ( "%o" % get_mode(target_file) ).should_not == "100640"
+      end
+    end
+
+  end
+
+end

data/spec/integration/type/tidy_spec.rb

@@ -17,7 +17,7 @@ describe Puppet::Type.type(:tidy) do
     link = File.join(dir, "link")
     target = tmpfile("no_such_file_tidy_link_testing")
     Dir.mkdir(dir)
-    Puppet::FileSystem::File.new(target).symlink(link)
+    Puppet::FileSystem.symlink(target, link)
 
     tidy = Puppet::Type.type(:tidy).new :path => dir, :recurse => true
 
@@ -26,6 +26,6 @@ describe Puppet::Type.type(:tidy) do
 
     catalog.apply
 
-    Puppet::FileSystem::File.new(link).symlink?.should be_false
+    Puppet::FileSystem.symlink?(link).should be_false
   end
 end

data/spec/integration/util/execution_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Puppet::Util::Execution do
+  describe "#execpipe" do
+    it "should set LANG to C avoid localized output", :if => !Puppet.features.microsoft_windows? do
+      out = ""
+      Puppet::Util::Execution.execpipe('echo $LANG'){ |line| out << line.read.chomp }
+      expect(out).to eq("C")
+    end
+
+    it "should set LC_ALL to C avoid localized output", :if => !Puppet.features.microsoft_windows? do
+      out = ""
+      Puppet::Util::Execution.execpipe('echo $LC_ALL'){ |line| out << line.read.chomp }
+      expect(out).to eq("C")
+    end
+  end
+end

data/spec/integration/util/rdoc/parser_spec.rb

@@ -113,7 +113,7 @@ end
   end
 
   def file_exists_and_matches_content(file, *content_patterns)
-    Puppet::FileSystem::File.exist?(file).should(be_true, "Cannot find #{file}")
+    Puppet::FileSystem.exist?(file).should(be_true, "Cannot find #{file}")
     content_patterns.each do |pattern|
       content = File.read(file)
       content.should match(pattern)

data/spec/integration/util/settings_spec.rb

@@ -41,7 +41,7 @@ describe Puppet::Settings do
 
     settings.use(:main)
 
-    expect(Puppet::FileSystem::File.new(settings[:maindir]).stat.mode & 007777).to eq(Puppet.features.microsoft_windows? ? 0755 : 0750)
+    expect(Puppet::FileSystem.stat(settings[:maindir]).mode & 007777).to eq(0750)
   end
 
   it "reparses configuration if configuration file is touched", :if => !Puppet.features.microsoft_windows? do

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

@@ -25,6 +25,13 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
       :none => Win32::Security::SID::Nobody,
       :everyone => Win32::Security::SID::Everyone
     }
+    # The TCP/IP NetBIOS Helper service (aka 'lmhosts') has ended up
+    # disabled on some VMs for reasons we couldn't track down. This
+    # condition causes tests which rely on resolving UNC style paths
+    # (like \\localhost) to fail with unhelpful error messages.
+    # Put a check for this upfront to aid debug should this strike again.
+    service = Puppet::Type.type(:service).new(:name => 'lmhosts')
+    service.provider.status.should == :running
   end
 
   let (:sids) { @sids }
@@ -43,6 +50,14 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
     end
   end
 
+  def grant_everyone_full_access(path)
+    sd = winsec.get_security_descriptor(path)
+    everyone = 'S-1-1-0'
+    inherit = WindowsSecurityTester::OBJECT_INHERIT_ACE | WindowsSecurityTester::CONTAINER_INHERIT_ACE
+    sd.dacl.allow(everyone, Windows::File::FILE_ALL_ACCESS, inherit)
+    winsec.set_security_descriptor(path, sd)
+  end
+
   shared_examples_for "only child owner" do
     it "should allow child owner" do
       winsec.set_owner(sids[:guest], parent)
@@ -96,7 +111,7 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
 
         after :each do
           winsec.set_mode(WindowsSecurityTester::S_IRWXU, parent)
-          winsec.set_mode(WindowsSecurityTester::S_IRWXU, path) if Puppet::FileSystem::File.exist?(path)
+          winsec.set_mode(WindowsSecurityTester::S_IRWXU, path) if Puppet::FileSystem.exist?(path)
         end
 
         describe "#supports_acl?" do
@@ -363,7 +378,7 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
         end
 
         after :each do
-          if Puppet::FileSystem::File.exist?(path)
+          if Puppet::FileSystem.exist?(path)
             winsec.set_owner(sids[:current_user], path)
             winsec.set_mode(WindowsSecurityTester::S_IRWXU, path)
           end
@@ -616,6 +631,11 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
       path
     end
 
+    after :each do
+      # allow temp files to be cleaned up
+      grant_everyone_full_access(parent)
+    end
+
     it_behaves_like "a securable object" do
       def check_access(mode, path)
         if (mode & WindowsSecurityTester::S_IRUSR).nonzero?
@@ -682,6 +702,11 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
       path
     end
 
+    after :each do
+      # allow temp files to be cleaned up
+      grant_everyone_full_access(parent)
+    end
+
     it_behaves_like "a securable object" do
       def check_access(mode, path)
         if (mode & WindowsSecurityTester::S_IRUSR).nonzero?

data/spec/lib/matchers/include.rb

@@ -0,0 +1,27 @@
+module Matchers; module Include
+  extend RSpec::Matchers::DSL
+
+  matcher :include_in_any_order do |*matchers|
+    match do |enumerable|
+      @not_matched = []
+      expected.each do |matcher|
+        if enumerable.empty?
+          break
+        end
+
+        if found = enumerable.find { |elem| matcher.matches?(elem) }
+          enumerable = enumerable.reject { |elem| elem == found }
+        else
+          @not_matched << matcher
+        end
+      end
+
+
+      @not_matched.empty? && enumerable.empty?
+    end
+
+    failure_message_for_should do |enumerable|
+      "did not match #{@not_matched.collect(&:description).join(', ')} in #{enumerable.inspect}: <#{@not_matched.collect(&:failure_message_for_should).join('>, <')}>"
+    end
+  end
+end; end

data/spec/lib/matchers/include_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'matchers/include'
+
+describe "include matchers" do
+  include Matchers::Include
+
+  context :include_in_any_order do
+    it "matches an empty list" do
+      expect([]).to include_in_any_order()
+    end
+
+    it "matches a list with a single element" do
+      expect([1]).to include_in_any_order(eq(1))
+    end
+
+    it "does not match when an expected element is missing" do
+      expect([1]).to_not include_in_any_order(eq(2))
+    end
+
+    it "matches a list with 2 elements in a different order from the expectation" do
+      expect([1, 2]).to include_in_any_order(eq(2), eq(1))
+    end
+
+    it "does not match when there are more than just the expected elements" do
+      expect([1, 2]).to_not include_in_any_order(eq(1))
+    end
+
+    it "matches multiple, equal elements when there are multiple, equal exepectations" do
+      expect([1, 1]).to include_in_any_order(eq(1), eq(1))
+    end
+  end
+end

data/spec/lib/matchers/json.rb

@@ -1,111 +1,167 @@
-RSpec::Matchers.define :set_json_attribute do |*attributes|
-  def format
-    @format ||= Puppet::Network::FormatHandler.format('pson')
-  end
+module JSONMatchers
+  class SetJsonAttribute
+    def initialize(attributes)
+      @attributes = attributes
+    end
 
-  chain :to do |value|
-    @value = value
-  end
+    def format
+      @format ||= Puppet::Network::FormatHandler.format('pson')
+    end
 
-  def json(instance)
-    PSON.parse(instance.to_pson)
-  end
+    def json(instance)
+      PSON.parse(instance.to_pson)
+    end
 
-  def attr_value(attrs, instance)
-    attrs = attrs.dup
-    hash = json(instance)['data']
-    while attrs.length > 0
-      name = attrs.shift
-      hash = hash[name]
+    def attr_value(attrs, instance)
+      attrs = attrs.dup
+      hash = json(instance)['data']
+      while attrs.length > 0
+        name = attrs.shift
+        hash = hash[name]
+      end
+      hash
     end
-    hash
-  end
 
-  match do |instance|
-    result = attr_value(attributes, instance)
-    if @value
-      result == @value
-    else
-      ! result.nil?
+    def to(value)
+      @value = value
+      self
     end
-  end
 
-  failure_message_for_should do |instance|
-    if @value
-      "expected #{instance.inspect} to set #{attributes.inspect} to #{@value.inspect}; got #{attr_value(attributes, instance).inspect}"
-    else
-      "expected #{instance.inspect} to set #{attributes.inspect} but was nil"
+    def matches?(instance)
+      result = attr_value(@attributes, instance)
+      if @value
+        result == @value
+      else
+        ! result.nil?
+      end
     end
-  end
 
-  failure_message_for_should_not do |instance|
-    if @value
-      "expected #{instance.inspect} not to set #{attributes.inspect} to #{@value.inspect}"
-    else
-      "expected #{instance.inspect} not to set #{attributes.inspect} to nil"
+    def failure_message_for_should(instance)
+      if @value
+        "expected #{instance.inspect} to set #{@attributes.inspect} to #{@value.inspect}; got #{attr_value(@attributes, instance).inspect}"
+      else
+        "expected #{instance.inspect} to set #{@attributes.inspect} but was nil"
+      end
     end
-  end
-end
 
-RSpec::Matchers.define :set_json_document_type_to do |type|
-  def format
-    @format ||= Puppet::Network::FormatHandler.format('pson')
+    def failure_message_for_should_not(instance)
+      if @value
+        "expected #{instance.inspect} not to set #{@attributes.inspect} to #{@value.inspect}"
+      else
+        "expected #{instance.inspect} not to set #{@attributes.inspect} to nil"
+      end
+    end
   end
 
-  match do |instance|
-    json(instance)['document_type'] == type
-  end
+  class SetJsonDocumentTypeTo
+    def initialize(type)
+      @type = type
+    end
 
-  def json(instance)
-    PSON.parse(instance.to_pson)
-  end
+    def format
+      @format ||= Puppet::Network::FormatHandler.format('pson')
+    end
 
-  failure_message_for_should do |instance|
-    "expected #{instance.inspect} to set document_type to #{type.inspect}; got #{json(instance)['document_type'].inspect}"
-  end
+    def matches?(instance)
+      json(instance)['document_type'] == @type
+    end
 
-  failure_message_for_should_not do |instance|
-    "expected #{instance.inspect} not to set document_type to #{type.inspect}"
-  end
-end
+    def json(instance)
+      PSON.parse(instance.to_pson)
+    end
 
-RSpec::Matchers.define :read_json_attribute do |attribute|
-  def format
-    @format ||= Puppet::Network::FormatHandler.format('pson')
-  end
+    def failure_message_for_should(instance)
+      "expected #{instance.inspect} to set document_type to #{@type.inspect}; got #{json(instance)['document_type'].inspect}"
+    end
 
-  chain :from do |value|
-    @json = value
+    def failure_message_for_should_not(instance)
+      "expected #{instance.inspect} not to set document_type to #{@type.inspect}"
+    end
   end
 
-  chain :as do |as|
-    @value = as
-  end
+  class ReadJsonAttribute
+    def initialize(attribute)
+      @attribute = attribute
+    end
 
-  match do |klass|
-    raise "Must specify json with 'from'" unless @json
+    def format
+      @format ||= Puppet::Network::FormatHandler.format('pson')
+    end
 
-    @instance = format.intern(klass, @json)
-    if @value
-      @instance.send(attribute) == @value
-    else
-      ! @instance.send(attribute).nil?
+    def from(value)
+      @json = value
+      self
+    end
+
+    def as(as)
+      @value = as
+      self
+    end
+
+    def matches?(klass)
+      raise "Must specify json with 'from'" unless @json
+
+      @instance = format.intern(klass, @json)
+      if @value
+        @instance.send(@attribute) == @value
+      else
+        ! @instance.send(@attribute).nil?
+      end
+    end
+
+    def failure_message_for_should(klass)
+      if @value
+        "expected #{klass} to read #{@attribute} from #{@json} as #{@value.inspect}; got #{@instance.send(@attribute).inspect}"
+      else
+        "expected #{klass} to read #{@attribute} from #{@json} but was nil"
+      end
+    end
+
+    def failure_message_for_should_not(klass)
+      if @value
+        "expected #{klass} not to set #{@attribute} to #{@value}"
+      else
+        "expected #{klass} not to set #{@attribute} to nil"
+      end
     end
   end
 
-  failure_message_for_should do |klass|
-    if @value
-      "expected #{klass} to read #{attribute} from #{@json} as #{@value.inspect}; got #{@instance.send(attribute).inspect}"
-    else
-      "expected #{klass} to read #{attribute} from #{@json} but was nil"
+  if !Puppet.features.microsoft_windows?
+    require 'json'
+    require 'json-schema'
+
+    class SchemaMatcher
+      JSON_META_SCHEMA = JSON.parse(File.read('api/schemas/json-meta-schema.json'))
+
+      def initialize(schema)
+        @schema = schema
+      end
+
+      def matches?(json)
+        JSON::Validator.validate!(JSON_META_SCHEMA, @schema)
+        JSON::Validator.validate!(@schema, json)
+      end
     end
   end
 
-  failure_message_for_should_not do |klass|
-    if @value
-      "expected #{klass} not to set #{attribute} to #{@value}"
+  def validate_against(schema_file)
+    if Puppet.features.microsoft_windows?
+      pending("Schema checks cannot be done on windows because of json-schema problems")
     else
-      "expected #{klass} not to set #{attribute} to nil"
+      schema = JSON.parse(File.read(schema_file))
+      SchemaMatcher.new(schema)
     end
   end
+
+  def set_json_attribute(*attributes)
+    SetJsonAttribute.new(attributes)
+  end
+
+  def set_json_document_type_to(type)
+    SetJsonDocumentTypeTo.new(type)
+  end
+
+  def read_json_attribute(attribute)
+    ReadJsonAttribute.new(attribute)
+  end
 end