puppet 6.29.0 → 7.0.0

data/spec/unit/capability_spec.rb

@@ -1,414 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/compiler'
-
-describe 'Capability types' do
-  include PuppetSpec::Compiler
-  let(:env) { Puppet::Node::Environment.create(:testing, []) }
-  let(:node) { Puppet::Node.new('test', :environment => env) }
-  let(:loaders) { Puppet::Pops::Loaders.new(env) }
-
-  before(:each) do
-    allow_any_instance_of(Puppet::Parser::Compiler).to receive(:loaders).and_return(loaders)
-    Puppet.push_context({:loaders => loaders, :current_environment => env})
-    Puppet::Type.newtype :cap, :is_capability => true do
-      newparam :name
-      newparam :host
-    end
-  end
-
-  after(:each) do
-    Puppet::Type.rmtype(:cap)
-    Puppet.pop_context()
-  end
-
-  context 'annotations' do
-    it "adds a blueprint for a produced resource" do
-      catalog = compile_to_catalog(<<-MANIFEST, node)
-      define test($hostname) {
-        notify { "hostname ${hostname}":}
-      }
-
-      Test produces Cap {
-        host => $hostname
-      }
-    MANIFEST
-
-      krt = catalog.environment_instance.known_resource_types
-      type = krt.definition(:test)
-      expect(type.produces).to be_instance_of(Array)
-      prd = type.produces.first
-
-      expect(prd).to be_instance_of(Hash)
-      expect(prd[:capability]).to eq("Cap")
-      expect(prd[:mappings]).to be_instance_of(Hash)
-      expect(prd[:mappings]["host"]).to be_instance_of(Puppet::Parser::AST::PopsBridge::Expression)
-    end
-
-    it "adds a blueprint for a consumed resource" do
-      catalog = compile_to_catalog(<<-MANIFEST, node)
-      define test($hostname) {
-        notify { "hostname ${hostname}":}
-      }
-
-      Test consumes Cap {
-        host => $hostname
-      }
-    MANIFEST
-
-      krt = catalog.environment_instance.known_resource_types
-      type = krt.definition(:test)
-      expect(type.produces).to be_instance_of(Array)
-      cns = type.consumes.first
-
-      expect(cns).to be_instance_of(Hash)
-      expect(cns[:capability]).to eq("Cap")
-      expect(cns[:mappings]).to be_instance_of(Hash)
-      expect(cns[:mappings]["host"]).to be_instance_of(Puppet::Parser::AST::PopsBridge::Expression)
-    end
-
-    it 'can place define and consumes/produces in separate manifests' do
-      parse_results = []
-      parser = Puppet::Parser::ParserFactory.parser
-
-      parser.string = <<-MANIFEST
-        define test($hostname) {
-          notify { "hostname ${hostname}":}
-        }
-      MANIFEST
-      parse_results << parser.parse
-
-      parser.string = <<-MANIFEST
-        Test consumes Cap {
-          host => $hostname
-        }
-      MANIFEST
-      parse_results << parser.parse
-
-      main = Puppet::Parser::AST::Hostclass.new('', :code => Puppet::Parser::ParserFactory.code_merger.concatenate(parse_results))
-      allow_any_instance_of(Puppet::Node::Environment).to receive(:perform_initial_import).and_return(main)
-
-      type = compile_to_catalog(nil).environment_instance.known_resource_types.definition(:test)
-      expect(type.produces).to be_instance_of(Array)
-      cns = type.consumes.first
-
-      expect(cns).to be_instance_of(Hash)
-      expect(cns[:capability]).to eq('Cap')
-      expect(cns[:mappings]).to be_instance_of(Hash)
-      expect(cns[:mappings]['host']).to be_instance_of(Puppet::Parser::AST::PopsBridge::Expression)
-    end
-
-    it 'can place use a qualified name for defines that produces capabilities' do
-      parse_results = []
-      parser = Puppet::Parser::ParserFactory.parser
-
-      parser.string = <<-MANIFEST
-        class mod {
-          define test($hostname) {
-            notify { "hostname ${hostname}":}
-          }
-        }
-        include mod
-      MANIFEST
-      parse_results << parser.parse
-
-      parser.string = <<-MANIFEST
-        Mod::Test consumes Cap {
-          host => $hostname
-        }
-      MANIFEST
-      parse_results << parser.parse
-
-      main = Puppet::Parser::AST::Hostclass.new('', :code => Puppet::Parser::ParserFactory.code_merger.concatenate(parse_results))
-     allow_any_instance_of(Puppet::Node::Environment).to receive(:perform_initial_import).and_return(main)
-
-      type = compile_to_catalog(nil).environment_instance.known_resource_types.definition('Mod::Test')
-      expect(type.produces).to be_instance_of(Array)
-      cns = type.consumes.first
-
-      expect(cns).to be_instance_of(Hash)
-      expect(cns[:capability]).to eq('Cap')
-      expect(cns[:mappings]).to be_instance_of(Hash)
-      expect(cns[:mappings]['host']).to be_instance_of(Puppet::Parser::AST::PopsBridge::Expression)
-    end
-
-    it "does not allow operator '+>' in a mapping" do
-      expect do
-      compile_to_catalog(<<-MANIFEST, node)
-        define test($hostname) {
-          notify { "hostname ${hostname}":}
-        }
-
-        Test consumes Cap {
-          host +> $hostname
-        }
-      MANIFEST
-      end.to raise_error(Puppet::ParseErrorWithIssue, /Illegal \+> operation.*This operator can not be used in a Capability Mapping/)
-    end
-
-    it "does not allow operator '*=>' in a mapping" do
-      expect do
-        compile_to_catalog(<<-MANIFEST, node)
-        define test($hostname) {
-          notify { "hostname ${hostname}":}
-        }
-
-        Test consumes Cap {
-          *=> { host => $hostname }
-        }
-        MANIFEST
-      end.to raise_error(Puppet::ParseError, /The operator '\* =>' in a Capability Mapping is not supported/)
-    end
-
-    it "does not allow 'before' relationship to capability mapping" do
-      expect do
-        compile_to_catalog(<<-MANIFEST, node)
-        define test() {
-          notify { "hello":}
-        }
-
-        Test consumes Cap {}
-
-        test { one: before => Cap[cap] }
-        MANIFEST
-      end.to raise_error(Puppet::Error, /'before' is not a valid relationship to a capability/)
-    end
-
-    ["produces", "consumes"].each do |kw|
-      it "creates an error when #{kw} references nonexistent type" do
-        manifest = <<-MANIFEST
-        Test #{kw} Cap {
-          host => $hostname
-        }
-      MANIFEST
-
-        expect {
-          compile_to_catalog(manifest, node)
-        }.to raise_error(Puppet::Error,
-                         /#{kw} clause references nonexistent type Test/)
-      end
-    end
-  end
-
-  context 'exporting a capability' do
-    it "does not add produced resources that are not exported" do
-      manifest = <<-MANIFEST
-define test($hostname) {
-  notify { "hostname ${hostname}":}
-}
-
-Test produces Cap {
-  host => $hostname
-}
-
-test { one: hostname => "ahost" }
-    MANIFEST
-      catalog = compile_to_catalog(manifest, node)
-      expect(catalog.resource("Test[one]")).to be_instance_of(Puppet::Resource)
-      expect(catalog.resource_keys.find { |type, _| type == "Cap" }).to be_nil
-    end
-
-    it "adds produced resources that are exported" do
-      manifest = <<-MANIFEST
-define test($hostname) {
-  notify { "hostname ${hostname}":}
-}
-
-# The $hostname in the produces clause does not refer to this variable,
-# instead, it referes to the hostname property of the Test resource
-# that is producing the Cap
-$hostname = "other_host"
-
-Test produces Cap {
-  host => $hostname
-}
-
-test { one: hostname => "ahost", export => Cap[two] }
-    MANIFEST
-      catalog = compile_to_catalog(manifest, node)
-      expect(catalog.resource("Test[one]")).to be_instance_of(Puppet::Resource)
-
-      caps = catalog.resource_keys.select { |type, _| type == "Cap" }
-      expect(caps.size).to eq(1)
-
-      cap = catalog.resource("Cap[two]")
-      expect(cap).to be_instance_of(Puppet::Resource)
-      expect(cap["require"]).to eq("Test[one]")
-      expect(cap["host"]).to eq("ahost")
-      expect(cap.resource_type).to eq(Puppet::Type::Cap)
-      expect(cap.tags.any? { |t| t == 'producer:testing' }).to eq(true)
-    end
-  end
-
-  context 'consuming a capability' do
-    def make_catalog(instance)
-      manifest = <<-MANIFEST
-      define test($hostname = nohost) {
-        notify { "hostname ${hostname}":}
-      }
-
-      Test consumes Cap {
-        hostname => $host
-      }
-    MANIFEST
-      compile_to_catalog(manifest + instance, node)
-    end
-
-    def mock_cap_finding
-      cap = Puppet::Resource.new("Cap", "two")
-      cap["host"] = "ahost"
-      expect(Puppet::Resource::CapabilityFinder).to receive(:find).and_return(cap)
-      cap
-    end
-
-    it "does not fetch a consumed resource when consume metaparam not set" do
-      expect(Puppet::Resource::CapabilityFinder).not_to receive(:find)
-      catalog = make_catalog("test { one: }")
-      expect(catalog.resource_keys.find { |type, _| type == "Cap" }).to be_nil
-      expect(catalog.resource("Test", "one")["hostname"]).to eq("nohost")
-    end
-
-    it "sets hostname from consumed capability" do
-      cap = mock_cap_finding
-      catalog = make_catalog("test { one: consume => Cap[two] }")
-      expect(catalog.resource("Cap[two]")).to eq(cap)
-      expect(catalog.resource("Cap[two]")["host"]).to eq("ahost")
-      expect(catalog.resource("Test", "one")["hostname"]).to eq("ahost")
-    end
-
-    it "does not override explicit hostname property when consuming" do
-      cap = mock_cap_finding
-      catalog = make_catalog("test { one: hostname => other_host, consume => Cap[two] }")
-      expect(catalog.resource("Cap[two]")).to eq(cap)
-      expect(catalog.resource("Cap[two]")["host"]).to eq("ahost")
-      expect(catalog.resource("Test", "one")["hostname"]).to eq("other_host")
-    end
-
-    it "fetches required capability" do
-      cap = mock_cap_finding
-      catalog = make_catalog("test { one: require => Cap[two] }")
-      expect(catalog.resource("Cap[two]")).to eq(cap)
-      expect(catalog.resource("Cap[two]")["host"]).to eq("ahost")
-      expect(catalog.resource("Test", "one")["hostname"]).to eq("nohost")
-    end
-
-    ['export', 'consume'].each do |metaparam|
-
-      it "validates that #{metaparam} metaparameter rejects values that are not resources" do
-        expect { make_catalog("test { one: #{metaparam} => 'hello' }") }.to raise_error(Puppet::Error, /not a resource/)
-      end
-
-      it "validates that #{metaparam} metaparameter rejects resources that are not capability resources" do
-        expect { make_catalog("notify{hello:} test { one: #{metaparam} => Notify[hello] }") }.to raise_error(Puppet::Error, /not a capability resource/)
-      end
-    end
-
-    context 'producing/consuming resources' do
-
-      let(:ral) do
-        compile_to_ral(<<-MANIFEST, node)
-  define producer() {
-    notify { "producer":}
-  }
-
-  define consumer() {
-    notify { $title:}
-  }
-
-  Producer produces Cap {}
-
-  Consumer consumes Cap {}
-
-  producer {x: export => Cap[cap]}
-  consumer {x: consume => Cap[cap]}
-  consumer {y: require => Cap[cap]}
-        MANIFEST
-      end
-
-      let(:graph) do
-        graph = Puppet::Graph::RelationshipGraph.new(Puppet::Graph::SequentialPrioritizer.new)
-        graph.populate_from(ral)
-        graph
-      end
-
-      let(:capability) { ral.resource('Cap[cap]') }
-
-      it 'the produced resource depends on the producer' do
-        expect(graph.dependencies(capability).map {|d| d.to_s }).to include('Producer[x]')
-      end
-
-      it 'the consumer depends on the consumed resource' do
-        expect(graph.dependents(capability).map {|d| d.to_s }).to include('Consumer[x]')
-      end
-
-      it 'the consumer depends on the required resource' do
-        expect(graph.dependents(capability).map {|d| d.to_s }).to include('Consumer[y]')
-      end
-    end
-
-    context 'producing/consuming resources to/from classes' do
-
-      let(:ral) do
-        compile_to_ral(<<-MANIFEST, node)
-  define test($hostname) {
-    notify { $hostname:}
-  }
-
-  class producer($host) {
-    notify { p: }
-  }
-
-  class consumer($host) {
-    test { c: hostname => $host }
-  }
-
-  Class[producer] produces Cap {}
-
-  Class[consumer] consumes Cap {}
-
-  class { producer: host => 'produced.host', export => Cap[one]}
-  class { consumer: consume => Cap[one]}
-        MANIFEST
-      end
-
-      let(:graph) do
-        graph = Puppet::Graph::RelationshipGraph.new(Puppet::Graph::SequentialPrioritizer.new)
-        graph.populate_from(ral)
-        graph
-      end
-
-      let(:capability) { ral.resource('Cap[one]') }
-
-      it 'the produced resource depends on the producer' do
-        expect(graph.dependencies(capability).map {|d| d.to_s }).to include('Class[Producer]')
-      end
-
-      it 'the consumer depends on the consumed resource' do
-        expect(graph.dependents(capability).map {|d| d.to_s }).to include('Class[Consumer]')
-      end
-
-      it 'resource in the consumer class gets values from producer via the capability resource' do
-        expect(graph.dependents(capability).map {|d| d.to_s }).to include('Notify[produced.host]')
-      end
-    end
-  end
-
-  context 'and aliased resources' do
-    let(:drive) { Puppet::Util::Platform.windows? ? 'C:' : '' }
-    let(:code) { <<-PUPPET }
-      $dir='#{drive}/tmp/test'
-      $same_dir='#{drive}/tmp/test/'
-
-      file {$dir:
-        ensure => directory
-      }
-
-      file { $same_dir:
-        ensure => directory
-      }
-    PUPPET
-
-    it 'fails if a resource is defined and then redefined using name that results in the same alias' do
-      expect { compile_to_ral(code) }.to raise_error(/resource \["File", "#{drive}\/tmp\/test"\] already declared/)
-    end
-  end
-end

data/spec/unit/concurrent/thread_local_singleton_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-require 'puppet/concurrent/thread_local_singleton'
-
-class PuppetSpec::Singleton
-  extend Puppet::Concurrent::ThreadLocalSingleton
-end
-
-# Use the `equal?` matcher to ensure we get the same object
-describe Puppet::Concurrent::ThreadLocalSingleton do
-  it 'returns the same object for a single thread' do
-    expect(PuppetSpec::Singleton.singleton).to equal(PuppetSpec::Singleton.singleton)
-  end
-
-  it 'is not inherited for a newly created thread' do
-    main_thread_local = PuppetSpec::Singleton.singleton
-    Thread.new do
-      expect(main_thread_local).to_not equal(PuppetSpec::Singleton.singleton)
-    end.join
-  end
-
-  it 'does not leak outside a thread' do
-    thread_local = nil
-    Thread.new do
-      thread_local = PuppetSpec::Singleton.singleton
-    end.join
-    expect(thread_local).to_not equal(PuppetSpec::Singleton.singleton)
-  end
-
-  it 'is different for each thread' do
-    locals = []
-    Thread.new do
-      locals << PuppetSpec::Singleton.singleton
-    end.join
-    Thread.new do
-      locals << PuppetSpec::Singleton.singleton
-    end.join
-    expect(locals.first).to_not equal(locals.last)
-  end
-end

data/spec/unit/face/key_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-require 'puppet/face'
-
-describe Puppet::Face[:key, '0.0.1'] do
-  it "should be deprecated" do
-    expect(subject.deprecated?).to be_truthy
-  end
-end
-

data/spec/unit/face/module/search_spec.rb

@@ -1,231 +0,0 @@
-require 'spec_helper'
-require 'puppet/face'
-require 'puppet/application/module'
-require 'puppet/module_tool'
-
-describe "puppet module search" do
-  subject { Puppet::Face[:module, :current] }
-
-  let(:options) do
-    {}
-  end
-
-  describe Puppet::Application::Module do
-    subject do
-      app = Puppet::Application::Module.new
-      allow(app).to receive(:action).and_return(Puppet::Face.find_action(:module, :search))
-      app
-    end
-
-    before do
-      subject.render_as = :console
-      allow(Puppet::Util::Terminal).to receive(:width).and_return(100)
-    end
-
-    it 'should output nothing when receiving an empty dataset' do
-      expect(subject.render({:answers => [], :result => :success}, ['apache', {}])).to eq("No results found for 'apache'.")
-    end
-
-    it 'should return error and exit when error returned' do
-      results = {
-        :result => :failure,
-        :error => {
-          :oneline => 'Something failed',
-          :multiline => 'Something failed',
-        }
-      }
-      expect { subject.render(results, ['apache', {}]) }.to raise_error 'Something failed'
-    end
-
-    it 'should output a header when receiving a non-empty dataset' do
-      results = {
-        :result => :success,
-        :answers => [
-          {'full_name' => '', 'author' => '', 'desc' => '', 'tag_list' => [] },
-        ],
-      }
-
-      expect(subject.render(results, ['apache', {}])).to match(/NAME/)
-      expect(subject.render(results, ['apache', {}])).to match(/DESCRIPTION/)
-      expect(subject.render(results, ['apache', {}])).to match(/AUTHOR/)
-      expect(subject.render(results, ['apache', {}])).to match(/KEYWORDS/)
-    end
-
-    it 'should output the relevant fields when receiving a non-empty dataset' do
-      results = {
-        :result => :success,
-        :answers => [
-          {'full_name' => 'Name', 'author' => 'Author', 'desc' => 'Summary', 'tag_list' => ['tag1', 'tag2'] },
-        ]
-      }
-
-      expect(subject.render(results, ['apache', {}])).to match(/Name/)
-      expect(subject.render(results, ['apache', {}])).to match(/Author/)
-      expect(subject.render(results, ['apache', {}])).to match(/Summary/)
-      expect(subject.render(results, ['apache', {}])).to match(/tag1/)
-      expect(subject.render(results, ['apache', {}])).to match(/tag2/)
-    end
-
-    it 'should mark deprecated modules in search results' do
-      results = {
-        :result => :success,
-        :answers => [
-          {'full_name' => 'puppetlabs-corosync', 'deprecated_at' => Time.new, 'author' => 'Author', 'desc' => 'Summary', 'tag_list' => ['tag1', 'tag2'] },
-        ]
-      }
-
-      expect(subject.render(results, ['apache', {}])).to match(/puppetlabs-corosync.*DEPRECATED/i)
-    end
-
-    it 'should elide really long descriptions' do
-      results = {
-        :result => :success,
-        :answers => [
-          {
-            'full_name' => 'Name',
-            'author' => 'Author',
-            'desc' => 'This description is really too long to fit in a single data table, guys -- we should probably set about truncating it',
-            'tag_list' => ['tag1', 'tag2'],
-          },
-        ]
-      }
-
-      expect(subject.render(results, ['apache', {}])).to match(/\.{3}  @Author/)
-    end
-
-    it 'should never truncate the module name' do
-      results = {
-        :result => :success,
-        :answers => [
-          {
-            'full_name' => 'This-module-has-a-really-really-long-name',
-            'author' => 'Author',
-            'desc' => 'Description',
-            'tag_list' => ['tag1', 'tag2'],
-          },
-        ]
-      }
-
-      expect(subject.render(results, ['apache', {}])).to match(/This-module-has-a-really-really-long-name/)
-    end
-
-    it 'should never truncate the author name' do
-      results = {
-        :result => :success,
-        :answers => [
-          {
-            'full_name' => 'Name',
-            'author' => 'This-author-has-a-really-really-long-name',
-            'desc' => 'Description',
-            'tag_list' => ['tag1', 'tag2'],
-          },
-        ]
-      }
-
-      expect(subject.render(results, ['apache', {}])).to match(/@This-author-has-a-really-really-long-name/)
-    end
-
-    it 'should never remove tags that match the search term' do
-      results = {
-        :results => :success,
-        :answers => [
-          {
-            'full_name' => 'Name',
-            'author' => 'Author',
-            'desc' => 'Description',
-            'tag_list' => ['Supercalifragilisticexpialidocious'] + (1..100).map { |i| "tag#{i}" },
-          },
-        ]
-      }
-
-      expect(subject.render(results, ['Supercalifragilisticexpialidocious', {}])).to match(/Supercalifragilisticexpialidocious/)
-      expect(subject.render(results, ['Supercalifragilisticexpialidocious', {}])).not_to match(/tag/)
-    end
-
-    {
-      100 => "NAME          DESCRIPTION                                     AUTHOR         KEYWORDS#{' '*15}\n"\
-             "Name          This description is really too long to fit ...  @JohnnyApples  tag1 tag2 taggitty3#{' '*4}\n",
-
-      70  => "NAME          DESCRIPTION                 AUTHOR         KEYWORDS#{' '*5}\n"\
-             "Name          This description is rea...  @JohnnyApples  tag1 tag2#{' '*4}\n",
-
-      80  => "NAME          DESCRIPTION                        AUTHOR         KEYWORDS#{' '*8}\n"\
-             "Name          This description is really too...  @JohnnyApples  tag1 tag2#{' '*7}\n",
-
-      200 => "NAME          DESCRIPTION                                                                                                        AUTHOR         KEYWORDS#{' '*48}\n"\
-             "Name          This description is really too long to fit in a single data table, guys -- we should probably set about trunca...  @JohnnyApples  tag1 tag2 taggitty3#{' '*37}\n"
-    }.each do |width, expectation|
-      it "should resize the table to fit the screen, when #{width} columns" do
-        results = {
-          :result => :success,
-          :answers => [
-            {
-              'full_name' => 'Name',
-              'author' => 'JohnnyApples',
-              'desc' => 'This description is really too long to fit in a single data table, guys -- we should probably set about truncating it',
-              'tag_list' => ['tag1', 'tag2', 'taggitty3'],
-            },
-          ]
-        }
-
-        expect(Puppet::Util::Terminal).to receive(:width).and_return(width)
-        result = subject.render(results, ['apache', {}])
-        expect(result.lines.sort_by(&:length).last.chomp.length).to be <= width
-        expect(result).to eq(expectation)
-      end
-    end
-  end
-
-  describe "option validation" do
-    context "without any options" do
-      it "should require a search term" do
-        pattern = /wrong number of arguments/
-        expect { subject.search }.to raise_error ArgumentError, pattern
-      end
-    end
-
-    it "should accept the --module_repository option" do
-      forge = double("Puppet::Forge")
-      searcher = double("Searcher")
-      options[:module_repository] = "http://forge.example.com"
-
-      expect(Puppet::Forge).to receive(:new).with("http://forge.example.com").and_return(forge)
-      expect(Puppet::ModuleTool::Applications::Searcher).to receive(:new).with("puppetlabs-apache", forge, hash_including(options)).and_return(searcher)
-      expect(searcher).to receive(:run)
-
-      subject.search("puppetlabs-apache", options)
-    end
-  end
-
-  describe "inline documentation" do
-    subject { Puppet::Face[:module, :current].get_action :search }
-
-    its(:summary)     { should =~ /search.*module/im }
-    its(:description) { should =~ /search.*module/im }
-    its(:returns)     { should =~ /array/i }
-    its(:examples)    { should_not be_empty }
-
-    %w{ license copyright summary description returns examples }.each do |doc|
-      context "of the" do
-        its(doc.to_sym) { should_not =~ /(FIXME|REVISIT|TODO)/ }
-      end
-    end
-  end
-
-  it "should include a deprecation warning" do
-    stub_request(:get, "https://forgeapi.puppet.com/v3/modules?query=puppetlabs-apache").to_return(status: 200, body: [answers: [], result: :success])
-
-    subject.search("puppetlabs-apache")
-
-    expect(@logs).to include(an_object_having_attributes(level: :warning, message: /This action has been deprecated. Please use the Puppet Forge to search for modules./))
-  end
-
-  it "omits the warning when deprecations are disabled" do
-    stub_request(:get, "https://forgeapi.puppet.com/v3/modules?query=puppetlabs-apache").to_return(status: 200, body: [answers: [], result: :success])
-
-    Puppet[:disable_warnings] = 'deprecations'
-    subject.search("puppetlabs-apache")
-
-    expect(@logs).not_to include(an_object_having_attributes(level: :warning))
-  end
-end