puppet 7.28.0-x86-mingw32 → 7.29.1-x86-mingw32

data/spec/lib/puppet_spec/compiler.rb

@@ -1,112 +0,0 @@
-module PuppetSpec::Compiler
-  module_function
-
-  def compile_to_catalog(string, node = Puppet::Node.new('test'))
-    Puppet[:code] = string
-    # see lib/puppet/indirector/catalog/compiler.rb#filter
-    Puppet::Parser::Compiler.compile(node).filter { |r| r.virtual? }
-  end
-
-  # Does not removed virtual resources in compiled catalog (i.e. keeps unrealized)
-  def compile_to_catalog_unfiltered(string, node = Puppet::Node.new('test'))
-    Puppet[:code] = string
-    # see lib/puppet/indirector/catalog/compiler.rb#filter
-    Puppet::Parser::Compiler.compile(node)
-  end
-
-  def compile_to_ral(manifest, node = Puppet::Node.new('test'))
-    catalog = compile_to_catalog(manifest, node)
-    ral = catalog.to_ral
-    ral.finalize
-    ral
-  end
-
-  def compile_to_relationship_graph(manifest, prioritizer = Puppet::Graph::SequentialPrioritizer.new)
-    ral = compile_to_ral(manifest)
-    graph = Puppet::Graph::RelationshipGraph.new(prioritizer)
-    graph.populate_from(ral)
-    graph
-  end
-
-  def apply_compiled_manifest(manifest, prioritizer = Puppet::Graph::SequentialPrioritizer.new)
-    catalog = compile_to_ral(manifest)
-    if block_given?
-      catalog.resources.each { |res| yield res }
-    end
-    transaction = Puppet::Transaction.new(catalog,
-                                         Puppet::Transaction::Report.new,
-                                         prioritizer)
-    transaction.evaluate
-    transaction.report.finalize_report
-
-    transaction
-  end
-
-  def apply_with_error_check(manifest)
-    apply_compiled_manifest(manifest) do |res|
-      expect(res).not_to receive(:err)
-    end
-  end
-
-  def order_resources_traversed_in(relationships)
-    order_seen = []
-    relationships.traverse { |resource| order_seen << resource.ref }
-    order_seen
-  end
-
-  def collect_notices(code, node = Puppet::Node.new('foonode'))
-    Puppet[:code] = code
-    compiler = Puppet::Parser::Compiler.new(node)
-    node.environment.check_for_reparse
-    logs = []
-    Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
-      yield(compiler)
-    end
-    logs = logs.select { |log| log.level == :notice }.map { |log| log.message }
-    logs
-  end
-
-  def eval_and_collect_notices(code, node = Puppet::Node.new('foonode'), topscope_vars = {})
-    collect_notices(code, node) do |compiler|
-      unless topscope_vars.empty?
-        scope = compiler.topscope
-        topscope_vars.each {|k,v| scope.setvar(k, v) }
-      end
-      if block_given?
-        compiler.compile do |catalog|
-          yield(compiler.topscope, catalog)
-          catalog
-        end
-      else
-        compiler.compile
-      end
-    end
-  end
-
-  # Compiles a catalog, and if source is given evaluates it and returns its result.
-  # The catalog is returned if no source is given.
-  # Topscope variables are set before compilation
-  # Uses a created node 'testnode' if none is given.
-  # (Parameters given by name)
-  #
-  def evaluate(code: 'undef', source: nil, node: Puppet::Node.new('testnode'), variables: {})
-    source_location = caller[0]
-    Puppet[:code] = code
-    compiler = Puppet::Parser::Compiler.new(node)
-    unless variables.empty?
-      scope = compiler.topscope
-      variables.each {|k,v| scope.setvar(k, v) }
-    end
-
-    if source.nil?
-      compiler.compile
-      # see lib/puppet/indirector/catalog/compiler.rb#filter
-      return compiler.filter { |r| r.virtual? }
-    end
-
-    # evaluate given source is the context of the compiled state and return its result
-    compiler.compile do |catalog |
-      Puppet::Pops::Parser::EvaluatingParser.singleton.evaluate_string(compiler.topscope, source, source_location)
-    end
-  end
-end

data/spec/lib/puppet_spec/files.rb

@@ -1,107 +0,0 @@
-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
-        FileUtils.rm_rf path, secure: true
-      rescue Errno::ENOENT
-        # nothing to do
-      end
-    end
-  end
-
-  module_function
-
-  def make_absolute(path)
-    path = File.expand_path(path)
-    path[0] = 'c' if Puppet::Util::Platform.windows?
-    path
-  end
-
-  def tmpfile(name, dir = nil)
-    dir ||= Dir.tmpdir
-    path = Puppet::FileSystem.expand_path(make_tmpname(name, nil).encode(Encoding::UTF_8), dir)
-    record_tmp(File.expand_path(path))
-
-    path
-  end
-
-  def file_containing(name, contents)
-    file = tmpfile(name)
-    File.open(file, 'wb') { |f| f.write(contents) }
-    file
-  end
-
-  def script_containing(name, contents)
-    file = tmpfile(name)
-    if Puppet::Util::Platform.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)
-    dir = Puppet::FileSystem.expand_path(Dir.mktmpdir(name).encode!(Encoding::UTF_8))
-
-    record_tmp(dir)
-
-    dir
-  end
-
-  # Copied from ruby 2.4 source
-  def make_tmpname((prefix, suffix), n)
-    prefix = (String.try_convert(prefix) or
-              raise ArgumentError, "unexpected prefix: #{prefix.inspect}")
-    suffix &&= (String.try_convert(suffix) or
-                raise ArgumentError, "unexpected suffix: #{suffix.inspect}")
-    t = Time.now.strftime("%Y%m%d")
-    path = "#{prefix}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}".dup
-    path << "-#{n}" if n
-    path << suffix if suffix
-    path
-  end
-
-  def dir_containing(name, contents_hash)
-    dir_contained_in(tmpdir(name), contents_hash)
-  end
-
-  def 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 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::Util::Platform.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

@@ -1,52 +0,0 @@
-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
-
-  def pem_content(name)
-    File.read(File.join(PuppetSpec::FIXTURE_DIR, 'ssl', name), encoding: 'UTF-8')
-  end
-
-  def cert_fixture(name)
-    OpenSSL::X509::Certificate.new(pem_content(name))
-  end
-
-  def crl_fixture(name)
-    OpenSSL::X509::CRL.new(pem_content(name))
-  end
-
-  def key_fixture(name)
-    OpenSSL::PKey::RSA.new(pem_content(name))
-  end
-
-  def ec_key_fixture(name)
-    OpenSSL::PKey::EC.new(pem_content(name))
-  end
-
-  def request_fixture(name)
-    OpenSSL::X509::Request.new(pem_content(name))
-  end
-end

data/spec/lib/puppet_spec/handler.rb

@@ -1,53 +0,0 @@
-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/https.rb

@@ -1,95 +0,0 @@
-require 'spec_helper'
-require 'webrick'
-
-class PuppetSpec::HTTPSServer
-  include PuppetSpec::Fixtures
-
-  attr_reader :ca_cert, :ca_crl, :server_cert, :server_key
-
-  def initialize(ca_cert: nil, ca_crl: nil, server_key: nil, server_cert: nil)
-    @ca_cert = ca_cert || cert_fixture('ca.pem')
-    @ca_crl = ca_crl || crl_fixture('crl.pem')
-    @server_key = server_key || key_fixture('127.0.0.1-key.pem')
-    @server_cert = server_cert || cert_fixture('127.0.0.1.pem')
-    @config = WEBrick::Config::HTTP.dup
-  end
-
-  def handle_request(ctx, ssl, response_proc)
-    req = WEBrick::HTTPRequest.new(@config)
-    req.parse(ssl)
-
-    # always drain request body
-    req.body
-
-    res = WEBrick::HTTPResponse.new(@config)
-    res.status = 200
-    res.body = 'OK'
-    # The server explicitly closes the connection after handling it,
-    # so explicitly tell the client we're not going to keep it open.
-    # Without this, ruby will add `Connection: Keep-Alive`, which
-    # confuses the client when it tries to reuse the half-closed
-    # connection.
-    res['Connection'] = 'close'
-    response_proc.call(req, res) if response_proc
-
-    res.send_response(ssl)
-  end
-
-  def start_server(ctx_proc: nil, response_proc: nil, &block)
-    errors = []
-
-    IO.pipe {|stop_pipe_r, stop_pipe_w|
-      store = OpenSSL::X509::Store.new
-      Array(@ca_cert).each { |c| store.add_cert(c) }
-      store.purpose = OpenSSL::X509::PURPOSE_SSL_CLIENT
-      ctx = OpenSSL::SSL::SSLContext.new
-      ctx.cert_store = store
-      ctx.cert = @server_cert
-      ctx.key = @server_key
-      ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE
-      ctx_proc.call(ctx) if ctx_proc
-
-      Socket.do_not_reverse_lookup = true
-      tcps = TCPServer.new("127.0.0.1", 0)
-      begin
-        port = tcps.connect_address.ip_port
-        begin
-          server_thread = Thread.new do
-            begin
-              ssls = OpenSSL::SSL::SSLServer.new(tcps, ctx)
-              ssls.start_immediately = true
-
-              loop do
-                readable, = IO.select([ssls, stop_pipe_r])
-                break if readable.include?(stop_pipe_r)
-
-                ssl = ssls.accept
-                begin
-                  handle_request(ctx, ssl, response_proc)
-                ensure
-                  ssl.close
-                end
-              end
-            rescue => e
-              # uncomment this line if something goes wrong
-              # puts "SERVER #{e.message}"
-              errors << e
-            end
-          end
-
-          begin
-            yield port
-          ensure
-            stop_pipe_w.close
-          end
-        ensure
-          server_thread.join
-        end
-      ensure
-        tcps.close
-      end
-    }
-
-    errors
-  end
-end

data/spec/lib/puppet_spec/language.rb

@@ -1,75 +0,0 @@
-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)
-
-            Puppet.override(:loaders => compiler.loaders) do
-              expect(evaluator.evaluate_string(compiler.topscope, resources)).to eq(true)
-            end
-          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

@@ -1,68 +0,0 @@
-require 'stringio'
-
-########################################################################
-# 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 :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

@@ -1,56 +0,0 @@
-require 'puppet/util/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(Puppet::Util::Json.dump(release.metadata))
-        end
-      end
-
-      def mark_changed(path)
-        app = Puppet::ModuleTool::Applications::Checksummer
-        allow(app).to receive(:run).with(path).and_return(['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?(SemanticPuppet::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)
-        SemanticPuppet::Version.parse(str)
-      end
-    end
-  end
-end