puppet 4.4.0-universal-darwin

data/spec/lib/puppet_spec/files.rb

@@ -0,0 +1,103 @@
+require 'fileutils'
+require 'tempfile'
+require 'tmpdir'
+require 'pathname'
+
+# A support module for testing files.
+module PuppetSpec::Files
+  def self.cleanup
+    $global_tempfiles ||= []
+    while path = $global_tempfiles.pop do
+      begin
+        Dir.unstub(:entries)
+        FileUtils.rm_rf path, :secure => true
+      rescue Errno::ENOENT
+        # nothing to do
+      end
+    end
+  end
+
+  def make_absolute(path) PuppetSpec::Files.make_absolute(path) end
+  def self.make_absolute(path)
+    path = File.expand_path(path)
+    path[0] = 'c' if Puppet.features.microsoft_windows?
+    path
+  end
+
+  def tmpfile(name, dir = nil) PuppetSpec::Files.tmpfile(name, dir) end
+  def self.tmpfile(name, dir = nil)
+    # Generate a temporary file, just for the name...
+    source = dir ? Tempfile.new(name, dir) : Tempfile.new(name)
+    path = source.path.encode(Encoding::UTF_8)
+    source.close!
+
+    record_tmp(File.expand_path(path))
+
+    path
+  end
+
+  def file_containing(name, contents) PuppetSpec::Files.file_containing(name, contents) end
+  def self.file_containing(name, contents)
+    file = tmpfile(name)
+    File.open(file, 'wb') { |f| f.write(contents) }
+    file
+  end
+
+  def script_containing(name, contents) PuppetSpec::Files.script_containing(name, contents) end
+  def self.script_containing(name, contents)
+    file = tmpfile(name)
+    if Puppet.features.microsoft_windows?
+      file += '.bat'
+      text = contents[:windows]
+    else
+      text = contents[:posix]
+    end
+    File.open(file, 'wb') { |f| f.write(text) }
+    Puppet::FileSystem.chmod(0755, file)
+    file
+  end
+
+  def tmpdir(name) PuppetSpec::Files.tmpdir(name) end
+  def self.tmpdir(name)
+    dir = Dir.mktmpdir(name).encode!(Encoding::UTF_8)
+
+    record_tmp(dir)
+
+    dir
+  end
+
+  def dir_containing(name, contents_hash) PuppetSpec::Files.dir_containing(name, contents_hash) end
+  def self.dir_containing(name, contents_hash)
+    dir_contained_in(tmpdir(name), contents_hash)
+  end
+
+  def dir_contained_in(dir, contents_hash) PuppetSpec::Files.dir_contained_in(dir, contents_hash) end
+  def self.dir_contained_in(dir, contents_hash)
+    contents_hash.each do |k,v|
+      if v.is_a?(Hash)
+        Dir.mkdir(tmp = File.join(dir,k))
+        dir_contained_in(tmp, v)
+      else
+        file = File.join(dir, k)
+        File.open(file, 'wb') {|f| f.write(v) }
+      end
+    end
+    dir
+  end
+
+  def self.record_tmp(tmp)
+    # ...record it for cleanup,
+    $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
+    expect(actual_mode).to eq(target_mode)
+  end
+end

data/spec/lib/puppet_spec/fixtures.rb

@@ -0,0 +1,28 @@
+module PuppetSpec::Fixtures
+  def fixtures(*rest)
+    File.join(PuppetSpec::FIXTURE_DIR, *rest)
+  end
+  def my_fixture_dir
+    callers = caller
+    while line = callers.shift do
+      next unless found = line.match(%r{/spec/(.*)_spec\.rb:})
+      return fixtures(found[1])
+    end
+    fail "sorry, I couldn't work out your path from the caller stack!"
+  end
+  def my_fixture(name)
+    file = File.join(my_fixture_dir, name)
+    unless File.readable? file then
+      fail Puppet::DevError, "fixture '#{name}' for #{my_fixture_dir} is not readable"
+    end
+    return file
+  end
+  def my_fixtures(glob = '*', flags = 0)
+    files = Dir.glob(File.join(my_fixture_dir, glob), flags)
+    unless files.length > 0 then
+      fail Puppet::DevError, "fixture '#{glob}' for #{my_fixture_dir} had no files!"
+    end
+    block_given? and files.each do |file| yield file end
+    files
+  end
+end

data/spec/lib/puppet_spec/handler.rb

@@ -0,0 +1,53 @@
+require 'puppet/network/http/handler'
+
+class PuppetSpec::Handler
+  include Puppet::Network::HTTP::Handler
+
+  def initialize(* routes)
+    register(routes)
+  end
+
+  def set_content_type(response, format)
+    response[:content_type_header] = format
+  end
+
+  def set_response(response, body, status = 200)
+    response[:body] = body
+    response[:status] = status
+  end
+
+  def http_method(request)
+    request[:method]
+  end
+
+  def path(request)
+    request[:path]
+  end
+
+  def params(request)
+    request[:params]
+  end
+
+  def client_cert(request)
+    request[:client_cert]
+  end
+
+  def body(request)
+    request[:body]
+  end
+
+  def headers(request)
+    request[:headers] || {}
+  end
+end
+
+class PuppetSpec::HandlerProfiler
+  def start(metric, description)
+  end
+
+  def finish(context, metric, description)
+  end
+
+  def shutdown()
+  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

@@ -0,0 +1,161 @@
+require 'stringio'
+
+########################################################################
+# Backward compatibility for Jenkins outdated environment.
+module RSpec
+  module Matchers
+    module BlockAliases
+      alias_method :to,     :should      unless method_defined? :to
+      alias_method :to_not, :should_not  unless method_defined? :to_not
+      alias_method :not_to, :should_not  unless method_defined? :not_to
+    end
+  end
+end
+
+
+########################################################################
+# Custom matchers...
+RSpec::Matchers.define :have_matching_element do |expected|
+  match do |actual|
+    actual.any? { |item| item =~ expected }
+  end
+end
+
+RSpec::Matchers.define :have_matching_log do |expected|
+  match do |actual|
+    actual.map(&:to_s).any? { |item| item =~ expected }
+  end
+end
+
+RSpec::Matchers.define :exit_with do |expected|
+  actual = nil
+  match do |block|
+    begin
+      block.call
+    rescue SystemExit => e
+      actual = e.status
+    end
+    actual and actual == expected
+  end
+
+  supports_block_expectations
+
+  failure_message do |block|
+    "expected exit with code #{expected} but " +
+      (actual.nil? ? " exit was not called" : "we exited with #{actual} instead")
+  end
+
+  failure_message_when_negated do |block|
+    "expected that exit would not be called with #{expected}"
+  end
+
+  description do
+    "expect exit with #{expected}"
+  end
+end
+
+
+RSpec::Matchers.define :have_printed do |expected|
+
+  case expected
+  when String, Regexp, Proc
+    expected = expected
+  else
+    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)
+      when Proc
+        expected.call(actual)
+      else
+        raise ArgumentError, "No idea how to match a #{actual.class.name}"
+    end
+  end
+
+  match do |block|
+    $stderr = $stdout = StringIO.new
+    $stdout.set_encoding('UTF-8') if $stdout.respond_to?(:set_encoding)
+
+    begin
+      block.call
+    rescue SystemExit => e
+      raise unless @expected_exit_code
+      @actual_exit_code = e.status
+    ensure
+      $stdout.rewind
+      @actual = $stdout.read
+
+      $stdout = STDOUT
+      $stderr = STDERR
+    end
+
+    matches_output?(@actual) && matches_exit_code?(@actual_exit_code)
+  end
+
+  supports_block_expectations
+
+  failure_message do |actual|
+    if actual.nil? then
+      "expected #{expected.inspect}, but nothing was printed"
+    else
+      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
+
+  failure_message_when_negated 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
+
+  description do
+    "expect #{expected.inspect} to be printed" + (@expected_exit_code.nil ? '' : " with exit code #{@expected_exit_code}")
+  end
+end
+
+RSpec::Matchers.define :equal_attributes_of do |expected|
+  match do |actual|
+    actual.instance_variables.all? do |attr|
+      actual.instance_variable_get(attr) == expected.instance_variable_get(attr)
+    end
+  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
+  end
+
+  failure_message do |actual|
+    "expected #{actual.inspect} to be one of #{expected.map(&:inspect).join(' or ')}"
+  end
+end

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

@@ -0,0 +1,56 @@
+require 'json'
+
+module PuppetSpec
+  module ModuleTool
+    module SharedFunctions
+      def remote_release(name, version)
+        remote_source.available_releases[name][version]
+      end
+
+      def preinstall(name, version, options = { :into => primary_dir })
+        release = remote_release(name, version)
+        raise "Could not preinstall #{name} v#{version}" if release.nil?
+
+        name = release.name[/-(.*)/, 1]
+        moddir = File.join(options[:into], name)
+        FileUtils.mkdir_p(moddir)
+        File.open(File.join(moddir, 'metadata.json'), 'w') do |file|
+          file.puts(JSON.generate(release.metadata))
+        end
+      end
+
+      def mark_changed(path)
+        app = Puppet::ModuleTool::Applications::Checksummer
+        app.stubs(:run).with(path).returns(['README'])
+      end
+
+      def graph_should_include(name, options)
+        releases = flatten_graph(subject[:graph] || [])
+        release = releases.find { |x| x[:name] == name }
+
+        if options.nil?
+          expect(release).to be_nil
+        else
+          from = options.keys.find { |k| k.nil? || k.is_a?(Semantic::Version) }
+          to   = options.delete(from)
+
+          if to or from
+            options[:previous_version] ||= from
+            options[:version] ||= to
+          end
+
+          expect(release).not_to be_nil
+          expect(release).to include options
+        end
+      end
+
+      def flatten_graph(graph)
+        graph + graph.map { |sub| flatten_graph(sub[:dependencies]) }.flatten
+      end
+
+      def v(str)
+        Semantic::Version.parse(str)
+      end
+    end
+  end
+end