puppet 7.28.0-universal-darwin → 7.29.0-universal-darwin

data/spec/unit/parser/templatewrapper_spec.rb

@@ -1,111 +0,0 @@
-require 'spec_helper'
-require 'puppet/parser/templatewrapper'
-
-describe Puppet::Parser::TemplateWrapper do
-  include PuppetSpec::Files
-
-  let(:known_resource_types) { Puppet::Resource::TypeCollection.new("env") }
-  let(:scope) do
-    compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
-    allow(compiler.environment).to receive(:known_resource_types).and_return(known_resource_types)
-    Puppet::Parser::Scope.new compiler
-  end
-
-  let(:tw) { Puppet::Parser::TemplateWrapper.new(scope) }
-
-  it "fails if a template cannot be found" do
-    expect(Puppet::Parser::Files).to receive(:find_template).and_return(nil)
-
-    expect { tw.file = "fake_template" }.to raise_error(Puppet::ParseError)
-  end
-
-  it "stringifies as template[<filename>] for a file based template" do
-    allow(Puppet::Parser::Files).to receive(:find_template).and_return("/tmp/fake_template")
-    tw.file = "fake_template"
-    expect(tw.to_s).to eql("template[/tmp/fake_template]")
-  end
-
-  it "stringifies as template[inline] for a string-based template" do
-    expect(tw.to_s).to eql("template[inline]")
-  end
-
-  it "reads and evaluates a file-based template" do
-    given_a_template_file("fake_template", "template contents")
-
-    tw.file = "fake_template"
-    expect(tw.result).to eql("template contents")
-  end
-
-  it "provides access to the name of the template via #file" do
-    full_file_name = given_a_template_file("fake_template", "<%= file %>")
-
-    tw.file = "fake_template"
-    expect(tw.result).to eq(full_file_name)
-  end
-
-  it "ignores a leading BOM" do
-    full_file_name = given_a_template_file("bom_template", "\uFEFF<%= file %>")
-
-    tw.file = "bom_template"
-    expect(tw.result).to eq(full_file_name)
-  end
-
-  it "evaluates a given string as a template" do
-    expect(tw.result("template contents")).to eql("template contents")
-  end
-
-  it "provides the defined classes with #classes" do
-    catalog = double('catalog', :classes => ["class1", "class2"])
-    expect(scope).to receive(:catalog).and_return(catalog)
-    expect(tw.classes).to eq(["class1", "class2"])
-  end
-
-  it "provides all the tags with #all_tags" do
-    catalog = double('catalog', :tags => ["tag1", "tag2"])
-    expect(scope).to receive(:catalog).and_return(catalog)
-    expect(tw.all_tags).to eq(["tag1","tag2"])
-  end
-
-  it "raises not implemented error" do
-    expect {
-      tw.tags
-    }.to raise_error(NotImplementedError, /Call 'all_tags' instead/)
-  end
-
-  it "raises error on access to removed in-scope variables via method calls" do
-    scope["in_scope_variable"] = "is good"
-    expect { tw.result("<%= in_scope_variable %>") }.to raise_error(/undefined local variable or method `in_scope_variable'/ )
-  end
-
-  it "reports that variable is available when it is in scope" do
-    scope["in_scope_variable"] = "is good"
-    expect(tw.result("<%= has_variable?('in_scope_variable') %>")).to eq("true")
-  end
-
-  it "reports that a variable is not available when it is not in scope" do
-    expect(tw.result("<%= has_variable?('not_in_scope_variable') %>")).to eq("false")
-  end
-
-  it "provides access to in-scope variables via instance variables" do
-    scope["one"] = "foo"
-    expect(tw.result("<%= @one %>")).to eq("foo")
-  end
-
-  %w{! . ; :}.each do |badchar|
-    it "translates #{badchar} to _ in instance variables" do
-      scope["one#{badchar}"] = "foo"
-      expect(tw.result("<%= @one_ %>")).to eq("foo")
-    end
-  end
-
-  def given_a_template_file(name, contents)
-    full_name = tmpfile("template_#{name}")
-    File.binwrite(full_name, contents)
-
-    allow(Puppet::Parser::Files).to receive(:find_template).
-      with(name, anything()).
-      and_return(full_name)
-
-    full_name
-  end
-end

data/spec/unit/parser/type_loader_spec.rb

@@ -1,202 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/parser/type_loader'
-require 'puppet/parser/parser_factory'
-require 'puppet_spec/modules'
-require 'puppet_spec/files'
-
-describe Puppet::Parser::TypeLoader do
-  include PuppetSpec::Modules
-  include PuppetSpec::Files
-
-  let(:empty_hostclass) { Puppet::Parser::AST::Hostclass.new('') }
-  let(:loader) { Puppet::Parser::TypeLoader.new(:myenv) }
-  let(:my_env) { Puppet::Node::Environment.create(:myenv, []) }
-
-  around do |example|
-    envs = Puppet::Environments::Static.new(my_env)
-
-    Puppet.override(:environments => envs) do
-      example.run
-    end
-  end
-
-  it "should support an environment" do
-    loader = Puppet::Parser::TypeLoader.new(:myenv)
-    expect(loader.environment.name).to eq(:myenv)
-  end
-
-  it "should delegate its known resource types to its environment" do
-    expect(loader.known_resource_types).to be_instance_of(Puppet::Resource::TypeCollection)
-  end
-
-  describe "when loading names from namespaces" do
-    it "should do nothing if the name to import is an empty string" do
-      expect(loader.try_load_fqname(:hostclass, "")).to be_nil
-    end
-
-    it "should attempt to import each generated name" do
-      expect(loader).to receive(:import_from_modules).with("foo/bar").and_return([])
-      expect(loader).to receive(:import_from_modules).with("foo").and_return([])
-      loader.try_load_fqname(:hostclass, "foo::bar")
-    end
-
-    it "should attempt to load each possible name going from most to least specific" do
-      ['foo/bar/baz', 'foo/bar', 'foo'].each do |path|
-        expect(Puppet::Parser::Files).to receive(:find_manifests_in_modules).with(path, anything).and_return([nil, []]).ordered
-      end
-
-      loader.try_load_fqname(:hostclass, 'foo::bar::baz')
-    end
-  end
-
-  describe "when importing" do
-    let(:stub_parser) { double('Parser', :file= => nil, :parse => empty_hostclass) }
-
-    before(:each) do
-      allow(Puppet::Parser::ParserFactory).to receive(:parser).and_return(stub_parser)
-    end
-
-    it "should find all manifests matching the file or pattern" do
-      expect(Puppet::Parser::Files).to receive(:find_manifests_in_modules).with("myfile", anything).and_return(["modname", %w{one}])
-      loader.import("myfile", "/path")
-    end
-
-    it "should pass the environment when looking for files" do
-      expect(Puppet::Parser::Files).to receive(:find_manifests_in_modules).with(anything, loader.environment).and_return(["modname", %w{one}])
-      loader.import("myfile", "/path")
-    end
-
-    it "should fail if no files are found" do
-      expect(Puppet::Parser::Files).to receive(:find_manifests_in_modules).and_return([nil, []])
-      expect { loader.import("myfile", "/path") }.to raise_error(/No file\(s\) found for import/)
-    end
-
-    it "should parse each found file" do
-      expect(Puppet::Parser::Files).to receive(:find_manifests_in_modules).and_return(["modname", [make_absolute("/one")]])
-      expect(loader).to receive(:parse_file).with(make_absolute("/one")).and_return(Puppet::Parser::AST::Hostclass.new(''))
-      loader.import("myfile", "/path")
-    end
-
-    it "should not attempt to import files that have already been imported" do
-      loader = Puppet::Parser::TypeLoader.new(:myenv)
-
-      expect(Puppet::Parser::Files).to receive(:find_manifests_in_modules).twice.and_return(["modname", %w{/one}])
-      expect(loader.import("myfile", "/path")).not_to be_empty
-
-      expect(loader.import("myfile", "/path")).to be_empty
-    end
-  end
-
-  describe "when importing all" do
-    let(:base) { tmpdir("base") }
-    let(:modulebase1) { File.join(base, "first") }
-    let(:modulebase2) { File.join(base, "second") }
-    let(:my_env) { Puppet::Node::Environment.create(:myenv, [modulebase1, modulebase2]) }
-
-    before do
-      # Create two module path directories
-      FileUtils.mkdir_p(modulebase1)
-      FileUtils.mkdir_p(modulebase2)
-    end
-
-    def mk_module(basedir, name)
-      PuppetSpec::Modules.create(name, basedir)
-    end
-
-    # We have to pass the base path so that we can
-    # write to modules that are in the second search path
-    def mk_manifests(base, mod, files)
-      files.collect do |file|
-        name = mod.name + "::" + file.gsub("/", "::")
-        path = File.join(base, mod.name, "manifests", file + ".pp")
-        FileUtils.mkdir_p(File.split(path)[0])
-
-        # write out the class
-        File.open(path, "w") { |f| f.print "class #{name} {}" }
-        name
-      end
-    end
-
-    it "should load all puppet manifests from all modules in the specified environment" do
-      module1 = mk_module(modulebase1, "one")
-      module2 = mk_module(modulebase2, "two")
-
-      mk_manifests(modulebase1, module1, %w{a b})
-      mk_manifests(modulebase2, module2, %w{c d})
-
-      loader.import_all
-
-      expect(loader.environment.known_resource_types.hostclass("one::a")).to be_instance_of(Puppet::Resource::Type)
-      expect(loader.environment.known_resource_types.hostclass("one::b")).to be_instance_of(Puppet::Resource::Type)
-      expect(loader.environment.known_resource_types.hostclass("two::c")).to be_instance_of(Puppet::Resource::Type)
-      expect(loader.environment.known_resource_types.hostclass("two::d")).to be_instance_of(Puppet::Resource::Type)
-    end
-
-    it "should not load manifests from duplicate modules later in the module path" do
-      module1 = mk_module(modulebase1, "one")
-
-      # duplicate
-      module2 = mk_module(modulebase2, "one")
-
-      mk_manifests(modulebase1, module1, %w{a})
-      mk_manifests(modulebase2, module2, %w{c})
-
-      loader.import_all
-
-      expect(loader.environment.known_resource_types.hostclass("one::c")).to be_nil
-    end
-
-    it "should load manifests from subdirectories" do
-      module1 = mk_module(modulebase1, "one")
-
-      mk_manifests(modulebase1, module1, %w{a a/b a/b/c})
-
-      loader.import_all
-
-      expect(loader.environment.known_resource_types.hostclass("one::a::b")).to be_instance_of(Puppet::Resource::Type)
-      expect(loader.environment.known_resource_types.hostclass("one::a::b::c")).to be_instance_of(Puppet::Resource::Type)
-    end
-
-    it "should skip modules that don't have manifests" do
-      mk_module(modulebase1, "one")
-      module2 = mk_module(modulebase2, "two")
-      mk_manifests(modulebase2, module2, %w{c d})
-
-      loader.import_all
-
-      expect(loader.environment.known_resource_types.hostclass("one::a")).to be_nil
-      expect(loader.environment.known_resource_types.hostclass("two::c")).to be_instance_of(Puppet::Resource::Type)
-      expect(loader.environment.known_resource_types.hostclass("two::d")).to be_instance_of(Puppet::Resource::Type)
-    end
-  end
-
-  describe "when parsing a file" do
-    it "requests a new parser instance for each file" do
-      parser = double('Parser', :file= => nil, :parse => empty_hostclass)
-
-      expect(Puppet::Parser::ParserFactory).to receive(:parser).twice.and_return(parser)
-
-      loader.parse_file("/my/file")
-      loader.parse_file("/my/other_file")
-    end
-
-    it "assigns the parser its file and then parses" do
-      parser = double('parser')
-
-      expect(Puppet::Parser::ParserFactory).to receive(:parser).and_return(parser)
-      expect(parser).to receive(:file=).with("/my/file")
-      expect(parser).to receive(:parse).and_return(empty_hostclass)
-
-      loader.parse_file("/my/file")
-    end
-  end
-
-  it "should be able to add classes to the current resource type collection" do
-    file = tmpfile("simple_file.pp")
-    File.open(file, "w") { |f| f.puts "class foo {}" }
-    loader.import(File.basename(file), File.dirname(file))
-
-    expect(loader.known_resource_types.hostclass("foo")).to be_instance_of(Puppet::Resource::Type)
-  end
-end

data/spec/unit/plan_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/files'
-require 'puppet_spec/modules'
-require 'puppet/module/plan'
-
-describe Puppet::Module::Plan do
-  include PuppetSpec::Files
-
-  let(:modpath) { tmpdir('plan_modpath') }
-  let(:mymodpath) { File.join(modpath, 'mymod') }
-  let(:othermodpath) { File.join(modpath, 'othermod') }
-  let(:mymod) { Puppet::Module.new('mymod', mymodpath, nil) }
-  let(:othermod) { Puppet::Module.new('othermod', othermodpath, nil) }
-  let(:plans_path) { File.join(mymodpath, 'plans') }
-  let(:other_plans_path) { File.join(othermodpath, 'plans') }
-  let(:plans_glob) { File.join(mymodpath, 'plans', '*') }
-
-  describe :naming do
-    word = (Puppet::Module::Plan::RESERVED_WORDS - Puppet::Module::Plan::RESERVED_DATA_TYPES).sample
-    datatype = (Puppet::Module::Plan::RESERVED_DATA_TYPES - Puppet::Module::Plan::RESERVED_WORDS).sample
-    test_cases = { 'iLegal.pp'  => 'Plan names must start with a lowercase letter and be composed of only lowercase letters, numbers, and underscores',
-                   'name.md'    => 'Plan name cannot have extension .md, must be .pp or .yaml',
-                   "#{word}.pp"     => "Plan name cannot be a reserved word, but was '#{word}'",
-                   "#{datatype}.pp" => "Plan name cannot be a Puppet data type, but was '#{datatype}'",
-                   'test_1.pp'    => nil,
-                   'test_2.yaml'  => nil }
-    test_cases.each do |filename, error|
-      it "constructs plans when needed with #{filename}" do
-        name = File.basename(filename, '.*')
-        if error
-          expect { Puppet::Module::Plan.new(mymod, name, [File.join(plans_path, filename)]) }
-            .to raise_error(Puppet::Module::Plan::InvalidName,
-                            error)
-        else
-          expect { Puppet::Module::Plan.new(mymod, name, [filename]) }
-            .not_to raise_error
-        end
-      end
-    end
-  end
-
-  it "finds all plans in module" do
-    og_files = %w{plan1.pp plan2.yaml not-a-plan.ok}.map { |bn| "#{plans_path}/#{bn}" }
-    expect(Dir).to receive(:glob).with(plans_glob).and_return(og_files)
-
-    plans = Puppet::Module::Plan.plans_in_module(mymod)
-
-    expect(plans.count).to eq(2)
-  end
-
-  it "selects .pp file before .yaml" do
-    og_files = %w{plan1.pp plan1.yaml}.map { |bn| "#{plans_path}/#{bn}" }
-    expect(Dir).to receive(:glob).with(plans_glob).and_return(og_files)
-
-    plans = Puppet::Module::Plan.plans_in_module(mymod)
-
-    expect(plans.count).to eq(1)
-    expect(plans.first.files.count).to eq(1)
-    expect(plans.first.files.first['name']).to eq('plan1.pp')
-  end
-
-  it "gives the 'init' plan a name that is just the module's name" do
-    expect(Puppet::Module::Plan.new(mymod, 'init', ["#{plans_path}/init.pp"]).name).to eq('mymod')
-  end
-end

data/spec/unit/pops/adaptable_spec.rb

@@ -1,139 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-
-describe Puppet::Pops::Adaptable::Adapter do
-  class ValueAdapter < Puppet::Pops::Adaptable::Adapter
-    attr_accessor :value
-  end
-
-  class OtherAdapter < Puppet::Pops::Adaptable::Adapter
-    attr_accessor :value
-    def OtherAdapter.create_adapter(o)
-      x = new
-      x.value="I am calling you Daffy."
-      x
-    end
-  end
-
-  module Farm
-    class FarmAdapter < Puppet::Pops::Adaptable::Adapter
-      attr_accessor :value
-    end
-  end
-
-  class Duck
-    include Puppet::Pops::Adaptable
-  end
-
-  it "should create specialized adapter instance on call to adapt" do
-    d = Duck.new
-    a = ValueAdapter.adapt(d)
-    expect(a.class).to eq(ValueAdapter)
-  end
-
-  it "should produce the same instance on multiple adaptations" do
-    d = Duck.new
-    a = ValueAdapter.adapt(d)
-    a.value = 10
-    b = ValueAdapter.adapt(d)
-    expect(b.value).to eq(10)
-  end
-
-  it "should return the correct adapter if there are several" do
-    d = Duck.new
-    a = ValueAdapter.adapt(d)
-    a.value = 10
-    b = ValueAdapter.adapt(d)
-    expect(b.value).to eq(10)
-  end
-
-  it "should allow specialization to override creating" do
-    d = Duck.new
-    a = OtherAdapter.adapt(d)
-    expect(a.value).to eq("I am calling you Daffy.")
-  end
-
-  it "should create a new adapter overriding existing" do
-    d = Duck.new
-    a = OtherAdapter.adapt(d)
-    expect(a.value).to eq("I am calling you Daffy.")
-    a.value = "Something different"
-    expect(a.value).to eq("Something different")
-    b = OtherAdapter.adapt(d)
-    expect(b.value).to eq("Something different")
-    b = OtherAdapter.adapt_new(d)
-    expect(b.value).to eq("I am calling you Daffy.")
-  end
-
-  it "should not create adapter on get" do
-    d = Duck.new
-    a = OtherAdapter.get(d)
-    expect(a).to eq(nil)
-  end
-
-  it "should return same adapter from get after adapt" do
-    d = Duck.new
-    a = OtherAdapter.get(d)
-    expect(a).to eq(nil)
-    a = OtherAdapter.adapt(d)
-    expect(a.value).to eq("I am calling you Daffy.")
-    b = OtherAdapter.get(d)
-    expect(b.value).to eq("I am calling you Daffy.")
-    expect(a).to eq(b)
-  end
-
-  it "should handle adapters in nested namespaces" do
-    d = Duck.new
-    a = Farm::FarmAdapter.get(d)
-    expect(a).to eq(nil)
-    a = Farm::FarmAdapter.adapt(d)
-    a.value = 10
-    b = Farm::FarmAdapter.get(d)
-    expect(b.value).to eq(10)
-  end
-
-  it "should be able to clear the adapter" do
-    d = Duck.new
-    a = OtherAdapter.adapt(d)
-    expect(a.value).to eq("I am calling you Daffy.")
-    # The adapter cleared should be returned
-    expect(OtherAdapter.clear(d).value).to eq("I am calling you Daffy.")
-    expect(OtherAdapter.get(d)).to eq(nil)
-  end
-
-  context "When adapting with #adapt it" do
-    it "should be possible to pass a block to configure the adapter" do
-      d = Duck.new
-      a = OtherAdapter.adapt(d) do |x|
-        x.value = "Donald"
-      end
-      expect(a.value).to eq("Donald")
-    end
-
-    it "should be possible to pass a block to configure the adapter and get the adapted" do
-      d = Duck.new
-      a = OtherAdapter.adapt(d) do |x, o|
-        x.value = "Donald, the #{o.class.name}"
-      end
-      expect(a.value).to eq("Donald, the Duck")
-    end
-  end
-
-  context "When adapting with #adapt_new it" do
-    it "should be possible to pass a block to configure the adapter" do
-      d = Duck.new
-      a = OtherAdapter.adapt_new(d) do |x|
-        x.value = "Donald"
-      end
-      expect(a.value).to eq("Donald")
-    end
-
-    it "should be possible to pass a block to configure the adapter and get the adapted" do
-      d = Duck.new
-      a = OtherAdapter.adapt_new(d) do |x, o|
-        x.value = "Donald, the #{o.class.name}"
-      end
-      expect(a.value).to eq("Donald, the Duck")
-    end
-  end
-end

data/spec/unit/pops/benchmark_spec.rb

@@ -1,123 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-require 'puppet_spec/pops'
-require 'puppet_spec/scope'
-
-describe "Benchmark", :benchmark => true do
-  include PuppetSpec::Pops
-  include PuppetSpec::Scope
-
-    def code
-      'if true
-{
-$a = 10 + 10
-}
-else
-{
-$a = "interpolate ${foo} and stuff"
-}
-'    end
-
-  class StringWriter < String
-    alias write concat
-  end
-
-  def json_dump(model)
-    output = StringWriter.new
-    ser = Puppet::Pops::Serialization::Serializer.new(Puppet::Pops::Serialization::JSON.writer.new(output))
-    ser.write(model)
-    ser.finish
-    output
-  end
-
-  it "transformer", :profile => true do
-    parser = Puppet::Pops::Parser::Parser.new()
-    model = parser.parse_string(code).model
-    transformer = Puppet::Pops::Model::AstTransformer.new()
-    m = Benchmark.measure { 10000.times { transformer.transform(model) }}
-    puts "Transformer: #{m}"
-  end
-
-  it "validator", :profile => true do
-    parser = Puppet::Pops::Parser::EvaluatingParser.new()
-    model = parser.parse_string(code)
-    m = Benchmark.measure { 100000.times { parser.assert_and_report(model) }}
-    puts "Validator: #{m}"
-  end
-
-  it "parse transform", :profile => true do
-    parser = Puppet::Pops::Parser::Parser.new()
-    transformer = Puppet::Pops::Model::AstTransformer.new()
-    m = Benchmark.measure { 10000.times { transformer.transform(parser.parse_string(code).model) }}
-    puts "Parse and transform: #{m}"
-  end
-
-  it "parser0", :profile => true do
-    parser = Puppet::Parser::Parser.new('test')
-    m = Benchmark.measure { 10000.times { parser.parse(code) }}
-    puts "Parser 0: #{m}"
-  end
-
-  it "parser1", :profile => true do
-    parser = Puppet::Pops::Parser::EvaluatingParser.new()
-    m = Benchmark.measure { 10000.times { parser.parse_string(code) }}
-    puts "Parser1: #{m}"
-  end
-
-  it "marshal1", :profile => true do
-    parser = Puppet::Pops::Parser::EvaluatingParser.new()
-    model = parser.parse_string(code).model
-    dumped = Marshal.dump(model)
-    m = Benchmark.measure { 10000.times { Marshal.load(dumped) }}
-    puts "Marshal1: #{m}"
-  end
-
-  it "rgenjson", :profile => true do
-    parser = Puppet::Pops::Parser::EvaluatingParser.new()
-    model = parser.parse_string(code).model
-    dumped = json_dump(model)
-    m = Benchmark.measure { 10000.times { json_load(dumped) }}
-    puts "Pcore Json: #{m}"
-  end
-
-  it "lexer2", :profile => true do
-    lexer = Puppet::Pops::Parser::Lexer2.new
-     m = Benchmark.measure {10000.times {lexer.string = code; lexer.fullscan }}
-     puts "Lexer2: #{m}"
-  end
-
-  it "lexer1", :profile => true do
-    lexer = Puppet::Pops::Parser::Lexer.new
-    m = Benchmark.measure {10000.times {lexer.string = code; lexer.fullscan }}
-    puts "Pops Lexer: #{m}"
-  end
-
-  it "lexer0", :profile => true do
-    lexer = Puppet::Parser::Lexer.new
-    m = Benchmark.measure {10000.times {lexer.string = code; lexer.fullscan }}
-    puts "Original Lexer: #{m}"
-  end
-
-  context "Measure Evaluator" do
-    let(:parser) { Puppet::Pops::Parser::EvaluatingParser.new }
-    let(:node) { 'node.example.com' }
-    let(:scope) { s = create_test_scope_for_node(node); s }
-    it "evaluator", :profile => true do
-      # Do the loop in puppet code since it otherwise drowns in setup
-      puppet_loop =
-        'Integer[0, 1000].each |$i| { if true
-{
-$a = 10 + 10
-}
-else
-{
-$a = "interpolate ${foo} and stuff"
-}}
-'
-      # parse once, only measure the evaluation
-      model = parser.parse_string(puppet_loop, __FILE__)
-      m = Benchmark.measure { parser.evaluate(create_test_scope_for_node(node), model) }
-      puts("Evaluator: #{m}")
-    end
-  end
-end