puppet 4.10.0 → 5.0.0

data/spec/unit/application/inspect_spec.rb

@@ -1,305 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-require 'puppet/application/inspect'
-require 'puppet/resource/catalog'
-require 'puppet/indirector/catalog/json'
-require 'puppet/indirector/report/rest'
-require 'puppet/indirector/file_bucket_file/rest'
-
-describe Puppet::Application::Inspect do
-  include PuppetSpec::Files
-
-  before :each do
-    @inspect = Puppet::Application[:inspect]
-    @inspect.preinit
-  end
-
-  it "should operate in agent run_mode" do
-    expect(@inspect.class.run_mode.name).to eq(:agent)
-  end
-
-  describe "during setup" do
-    it "should print its configuration if asked" do
-      Puppet[:configprint] = "all"
-
-      Puppet.settings.expects(:print_configs).returns(true)
-      expect { @inspect.setup }.to exit_with 0
-    end
-
-    it "should fail if reporting is turned off" do
-      Puppet[:report] = false
-      expect { @inspect.setup }.to raise_error(/report=true/)
-    end
-
-    it "should default to the json terminus class when catalog_cache_terminus is not set" do
-      Puppet::Resource::Catalog.indirection.expects(:terminus_class=).with(:json)
-      expect { @inspect.setup }.not_to raise_error
-    end
-
-    it "should respect the catalog_cache_terminus if set" do
-      Puppet[:catalog_cache_terminus] = :yaml
-      Puppet::Resource::Catalog.indirection.expects(:terminus_class=).with(:yaml)
-      expect { @inspect.setup }.not_to raise_error
-    end
-
-    it "should be marked as deprecated" do
-      @inspect.setup
-      expect(@inspect.deprecated?).to be true
-    end
-  end
-
-  describe "when executing", :uses_checksums => true do
-    before :each do
-      Puppet[:report] = true
-      @inspect.options[:setdest] = true
-      Puppet::Transaction::Report::Rest.any_instance.stubs(:save)
-      @inspect.setup
-    end
-
-    it "should retrieve the local catalog" do
-      Puppet::Resource::Catalog::Json.any_instance.expects(:find).with {|request| request.key == Puppet[:certname] }.returns(Puppet::Resource::Catalog.new)
-
-      @inspect.run_command
-    end
-
-    it "should save the report to REST" do
-      Puppet::Resource::Catalog::Json.any_instance.stubs(:find).returns(Puppet::Resource::Catalog.new)
-      Puppet::Transaction::Report::Rest.any_instance.expects(:save).with {|request| request.instance.host == Puppet[:certname] }
-
-      @inspect.run_command
-    end
-
-    with_digest_algorithms do
-      it "should audit the specified properties" do
-        catalog = Puppet::Resource::Catalog.new
-        file = Tempfile.new("foo")
-        file.binmode
-        file.print plaintext
-        file.close
-        resource = Puppet::Resource.new(:file, file.path, :parameters => {:audit => "all"})
-        catalog.add_resource(resource)
-        Puppet::Resource::Catalog::Json.any_instance.stubs(:find).returns(catalog)
-
-        events = nil
-
-        Puppet::Transaction::Report::Rest.any_instance.expects(:save).with do |request|
-          events = request.instance.resource_statuses.values.first.events
-        end
-
-        @inspect.run_command
-
-        properties = events.inject({}) do |property_values, event|
-          property_values.merge(event.property => event.previous_value)
-        end
-        expect(properties["ensure"]).to eq(:file)
-        expect(properties["content"]).to eq("{#{digest_algorithm}}#{checksum}")
-        expect(properties.has_key?("target")).to eq(false)
-      end
-    end
-
-    it "should set audited to true for all events" do
-      catalog = Puppet::Resource::Catalog.new
-      file = Tempfile.new("foo")
-      resource = Puppet::Resource.new(:file, file.path, :parameters => {:audit => "all"})
-      catalog.add_resource(resource)
-      Puppet::Resource::Catalog::Json.any_instance.stubs(:find).returns(catalog)
-
-      events = nil
-
-      Puppet::Transaction::Report::Rest.any_instance.expects(:save).with do |request|
-        events = request.instance.resource_statuses.values.first.events
-      end
-
-      @inspect.run_command
-
-      events.each do |event|
-        expect(event.audited).to eq(true)
-      end
-    end
-
-    it "should not report irrelevent attributes if the resource is absent" do
-      catalog = Puppet::Resource::Catalog.new
-      file = Tempfile.new("foo")
-      resource = Puppet::Resource.new(:file, file.path, :parameters => {:audit => "all"})
-      file.close
-      file.delete
-      catalog.add_resource(resource)
-      Puppet::Resource::Catalog::Json.any_instance.stubs(:find).returns(catalog)
-
-      events = nil
-
-      Puppet::Transaction::Report::Rest.any_instance.expects(:save).with do |request|
-        events = request.instance.resource_statuses.values.first.events
-      end
-
-      @inspect.run_command
-
-      properties = events.inject({}) do |property_values, event|
-        property_values.merge(event.property => event.previous_value)
-      end
-      expect(properties).to eq({"ensure" => :absent})
-    end
-
-    describe "when archiving to a bucket" do
-      before :each do
-        Puppet[:archive_files] = true
-        Puppet[:archive_file_server] = "filebucketserver"
-        @catalog = Puppet::Resource::Catalog.new
-        Puppet::Resource::Catalog::Json.any_instance.stubs(:find).returns(@catalog)
-      end
-
-      describe "when auditing files" do
-        before :each do
-          @file = tmpfile("foo")
-          @resource = Puppet::Resource.new(:file, @file, :parameters => {:audit => "content"})
-          @catalog.add_resource(@resource)
-        end
-
-        it "should send an existing file to the file bucket" do
-          File.open(@file, 'w') { |f| f.write('stuff') }
-          Puppet::FileBucketFile::Rest.any_instance.expects(:head).with do |request|
-            request.server == Puppet[:archive_file_server]
-          end.returns(false)
-          Puppet::FileBucketFile::Rest.any_instance.expects(:save).with do |request|
-            request.server == Puppet[:archive_file_server] and request.instance.contents == 'stuff'
-          end
-          @inspect.run_command
-        end
-
-        it "should not send unreadable files", :unless => (Puppet.features.microsoft_windows? || Puppet.features.root?) do
-          File.open(@file, 'w') { |f| f.write('stuff') }
-          File.chmod(0, @file)
-          Puppet::FileBucketFile::Rest.any_instance.expects(:head).never
-          Puppet::FileBucketFile::Rest.any_instance.expects(:save).never
-          @inspect.run_command
-        end
-
-        it "should not try to send non-existent files" do
-          Puppet::FileBucketFile::Rest.any_instance.expects(:head).never
-          Puppet::FileBucketFile::Rest.any_instance.expects(:save).never
-          @inspect.run_command
-        end
-
-        it "should not try to send files whose content we are not auditing" do
-          @resource[:audit] = "group"
-          Puppet::FileBucketFile::Rest.any_instance.expects(:head).never
-          Puppet::FileBucketFile::Rest.any_instance.expects(:save).never
-          @inspect.run_command
-        end
-
-        it "should continue if bucketing a file fails" do
-          File.open(@file, 'w') { |f| f.write('stuff') }
-          Puppet::FileBucketFile::Rest.any_instance.stubs(:head).returns false
-          Puppet::FileBucketFile::Rest.any_instance.stubs(:save).raises "failure"
-          Puppet::Transaction::Report::Rest.any_instance.expects(:save).with do |request|
-            @report = request.instance
-          end
-
-          @inspect.run_command
-
-          # First several errors are deprecation warnings, find correct log message
-          expect(@report.logs).to be_any { |l|
-            /Could not back up/.match(l.message)
-          }
-        end
-      end
-
-      describe "when auditing non-files" do
-        before :each do
-          Puppet::Type.newtype(:stub_type) do
-            newparam(:name) do
-              desc "The name var"
-              isnamevar
-            end
-
-            newproperty(:content) do
-              desc "content"
-              def retrieve
-                :whatever
-              end
-            end
-          end
-
-          @resource = Puppet::Resource.new(:stub_type, 'foo', :parameters => {:audit => "all"})
-          @catalog.add_resource(@resource)
-        end
-
-        after :each do
-          Puppet::Type.rmtype(:stub_type)
-        end
-
-        it "should not try to send non-files" do
-          Puppet::FileBucketFile::Rest.any_instance.expects(:head).never
-          Puppet::FileBucketFile::Rest.any_instance.expects(:save).never
-          @inspect.run_command
-        end
-      end
-    end
-
-    describe "when there are failures" do
-      before :each do
-        Puppet::Type.newtype(:stub_type) do
-          newparam(:name) do
-            desc "The name var"
-            isnamevar
-          end
-
-          newproperty(:content) do
-            desc "content"
-            def retrieve
-              raise "failed"
-            end
-          end
-        end
-
-        @catalog = Puppet::Resource::Catalog.new
-        Puppet::Resource::Catalog::Json.any_instance.stubs(:find).returns(@catalog)
-
-        Puppet::Transaction::Report::Rest.any_instance.expects(:save).with do |request|
-          @report = request.instance
-        end
-      end
-
-      after :each do
-        Puppet::Type.rmtype(:stub_type)
-      end
-
-      it "should mark the report failed and create failed events for each property" do
-        @resource = Puppet::Resource.new(:stub_type, 'foo', :parameters => {:audit => "all"})
-        @catalog.add_resource(@resource)
-
-        @inspect.run_command
-
-        expect(@report.status).to eq("failed")
-        expect(@report.logs.select{|log| log.message =~ /Could not inspect/}.size).to eq(1)
-        expect(@report.resource_statuses.size).to eq(1)
-        expect(@report.resource_statuses['Stub_type[foo]'].events.size).to eq(1)
-
-        event = @report.resource_statuses['Stub_type[foo]'].events.first
-        expect(event.property).to eq("content")
-        expect(event.status).to eq("failure")
-        expect(event.audited).to eq(true)
-        expect(event.instance_variables).not_to include "@previous_value"
-        expect(event.instance_variables).not_to include :@previous_value
-      end
-
-      it "should continue to the next resource" do
-        @resource = Puppet::Resource.new(:stub_type, 'foo', :parameters => {:audit => "all"})
-        @other_resource = Puppet::Resource.new(:stub_type, 'bar', :parameters => {:audit => "all"})
-        @catalog.add_resource(@resource)
-        @catalog.add_resource(@other_resource)
-
-        @inspect.run_command
-
-        expect(@report.resource_statuses.size).to eq(2)
-        expect(@report.resource_statuses.keys).to match_array(['Stub_type[foo]', 'Stub_type[bar]'])
-      end
-    end
-  end
-
-  after :all do
-    Puppet::Resource::Catalog.indirection.reset_terminus_class
-    Puppet::Transaction::Report.indirection.terminus_class = :processor
-  end
-end

data/spec/unit/data_providers/custom_data_provider_spec.rb

@@ -1,50 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-require 'puppet_spec/compiler'
-
-describe 'when using a custom data provider' do
-  include PuppetSpec::Compiler
-
-  # There is a fully configured 'sample' environment in fixtures at this location
-  let(:environmentpath) { parent_fixture('environments') }
-  let(:node) { Puppet::Node.new('testnode', :facts => Puppet::Node::Facts.new("facts", {}), :environment => 'sample') }
-
-  around(:each) do |example|
-    # Initialize settings to get a full compile as close as possible to a real
-    # environment load
-    Puppet.settings.initialize_global_settings
-    # Initialize loaders based on the environmentpath. It does not work to
-    # just set the setting environmentpath for some reason - this achieves the same:
-    # - first a loader is created, loading directory environments from the fixture (there is
-    # one environment, 'sample', which will be loaded since the node references this
-    # environment by name).
-    # - secondly, the created env loader is set as 'environments' in the puppet context.
-    #
-    loader = Puppet::Environments::Directories.new(environmentpath, [])
-    Puppet.override(:environments => loader) do
-      example.run
-    end
-  end
-
-  it 'the environment data loader is used to set parameters' do
-    code = <<-PUPPET.unindent
-      class test($param_a = 1, $param_b = 2, $param_c = 3) {
-        notice("$param_a, $param_b, $param_c")
-      }
-      include test
-    PUPPET
-    expect(eval_and_collect_notices(code, node)).to eql(['env data param_a is 10, env data param_b is 20, 3'])
-  end
-
-  it 'the module and environment data loader is used to set parameters' do
-    expect(eval_and_collect_notices('include dataprovider::test', node)).to eql(['module data param_a is 100, module data param_b is 200, env data param_c is 300'])
-  end
-
-  it 'the custom hiera backend in a module and the environment data loader is used to set parameters' do
-    expect(eval_and_collect_notices('include backend::test', node)).to eql(['module data param_a is 1000, module data param_b is 2000, env data param_c is 3000'])
-  end
-
-  def parent_fixture(dir_name)
-    File.absolute_path(File.join(my_fixture_dir(), "../#{dir_name}"))
-  end
-end

data/spec/unit/face/file_spec.rb

@@ -1,14 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-require 'puppet/face'
-
-describe Puppet::Face[:file, '0.0.1'] do
-  [:download, :store, :find, :info, :save].each do |action|
-    it { is_expected.to be_action action }
-    it { is_expected.to respond_to action }
-  end
-
-  it "should be deprecated" do
-    expect(subject.deprecated?).to be_truthy
-  end
-end

data/spec/unit/indirector/catalog/static_compiler_spec.rb

@@ -1,255 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-require 'puppet/indirector/catalog/static_compiler'
-require 'puppet/file_serving/metadata'
-require 'puppet/file_serving/content'
-require 'yaml'
-
-describe Puppet::Resource::Catalog::StaticCompiler do
-  before :all do
-    @num_file_resources = 10
-  end
-
-  before :each do
-    Facter.stubs(:loadfacts)
-    Facter.stubs(:to_hash).returns({})
-    Facter.stubs(:value)
-  end
-
-  around(:each) do |example|
-    Puppet.override({
-        :current_environment => Puppet::Node::Environment.create(:app, []),
-      },
-      "Ensure we are using an environment other than root"
-    ) do
-      example.run
-    end
-  end
-
-  let(:request) do
-    Puppet::Indirector::Request.new(:the_indirection_named_foo,
-                                    :find,
-                                    "the-node-named-foo",
-                                    :environment => "production")
-  end
-
-  describe "#find" do
-    before :each do
-      subject.stubs(:store_content)
-    end
-
-    it "returns a catalog" do
-      expect(subject.find(request)).to be_a_kind_of(Puppet::Resource::Catalog)
-    end
-
-    it "returns nil if there is no compiled catalog" do
-      subject.expects(:compile).returns(nil)
-      expect(subject.find(request)).to be_nil
-    end
-
-    describe "a catalog with file resources containing source parameters with puppet:// URIs" do
-      it "filters file resource source URI's to checksums" do
-        subject.stubs(:compile).returns(build_catalog)
-
-        resource_catalog = subject.find(request)
-        resource_catalog.resources.each do |resource|
-          next unless resource.type == "File"
-          expect(resource[:content]).to eq("{md5}361fadf1c712e812d198c4cab5712a79")
-          expect(resource[:source]).to be_nil
-        end
-      end
-
-      it "does not modify file resources with non-puppet:// URI's" do
-        uri = "/this/is/not/a/puppet/uri.txt"
-        subject.stubs(:compile).returns(build_catalog(:source => uri))
-
-        resource_catalog = subject.find(request)
-        resource_catalog.resources.each do |resource|
-          next unless resource.type == "File"
-          expect(resource[:content]).to be_nil
-          expect(resource[:source]).to eq(uri)
-        end
-      end
-
-      it "copies the owner, group and mode from the fileserver" do
-        subject.stubs(:compile).returns(build_catalog)
-
-        resource_catalog = subject.find(request)
-        resource_catalog.resources.each do |resource|
-          next unless resource.type == "File"
-          expect(resource[:owner]).to eq("0")
-          expect(resource[:group]).to eq("0")
-          expect(resource[:mode]).to  eq("644")
-        end
-      end
-
-      it "ignores recurse when source refers to a file" do
-        path = File.expand_path('/tmp/foo')
-        metadata = fileserver_metadata(:path => path)
-        metadata.relative_path = '.'
-
-        Puppet::FileServing::Metadata.indirection.stubs(:search).returns([metadata])
-        Puppet::FileServing::Metadata.indirection.stubs(:find).returns(metadata)
-
-        catalog = Puppet::Resource::Catalog.new(request)
-        catalog.add_resource(
-          Puppet::Resource.new('file', path,
-            :parameters => {
-              :recurse => true,
-              :source => 'puppet:///modules/mymodule/foo'
-            }
-          )
-        )
-        subject.stubs(:compile).returns(catalog)
-
-        resource = subject.find(request).resources.first
-        expect(resource[:ensure]).to eq('file')
-        expect(resource.title).to eq(path)
-      end
-    end
-  end
-
-  describe "(#15193) when storing content to the filebucket" do
-    it "explicitly uses the indirection method" do
-
-      # We expect the content to be retrieved from the FileServer ...
-      fake_content = mock('FileServer Content')
-      fake_content.expects(:content).returns("HELLO WORLD")
-
-      # Mock the FileBucket to behave as if the file content does not exist.
-      # NOTE, we're simulating the first call returning false, indicating the
-      # file is not present, then all subsequent calls returning true.  This
-      # mocked behavior is intended to replicate the real behavior of the same
-      # file being stored to the filebucket multiple times.
-      Puppet::FileBucket::File.indirection.
-        expects(:find).times(@num_file_resources).
-        returns(false).then.returns(true)
-
-      Puppet::FileServing::Content.indirection.
-        expects(:find).once.
-        returns(fake_content)
-
-      # Once retrived from the FileServer, we expect the file to be stored into
-      # the FileBucket only once.  All of the file resources in the fake
-      # catalog have the same content.
-      Puppet::FileBucket::File.indirection.expects(:save).once.with do |file|
-        file.contents == "HELLO WORLD"
-      end
-
-      # Obtain the Static Catalog
-      subject.stubs(:compile).returns(build_catalog)
-      resource_catalog = subject.find(request)
-
-      # Ensure all of the file resources were filtered
-      resource_catalog.resources.each do |resource|
-        next unless resource.type == "File"
-        expect(resource[:content]).to eq("{md5}361fadf1c712e812d198c4cab5712a79")
-        expect(resource[:source]).to be_nil
-      end
-    end
-  end
-
-  # Spec helper methods
-
-  def build_catalog(options = {})
-    options = options.dup
-    options[:source] ||= 'puppet:///modules/mymodule/config_file.txt'
-    options[:request] ||= request
-
-    # Build a catalog suitable for the static compiler to operate on
-    environment = Puppet::Node::Environment.remote(:testing)
-    catalog = Puppet::Resource::Catalog.new("#{options[:request].key}", environment)
-
-    # Mock out the fileserver, otherwise converting the catalog to a
-    fake_fileserver_metadata = fileserver_metadata(options)
-
-    # Stub the call to the FileServer metadata API so we don't have to have
-    # a real fileserver initialized for testing.
-    Puppet::FileServing::Metadata.
-      indirection.stubs(:find).with do |uri, opts|
-        expect(uri).to eq options[:source].sub('puppet:///','')
-        expect(opts[:links]).to eq :manage
-        expect(opts[:environment]).to eq environment
-      end.returns(fake_fileserver_metadata)
-
-    # I want a resource that all the file resources require and another
-    # that requires them.
-    resources = Array.new
-    resources << Puppet::Resource.new("notify", "alpha")
-    resources << Puppet::Resource.new("notify", "omega")
-
-    # Create some File resources with source parameters.
-    1.upto(@num_file_resources) do |idx|
-      parameters = {
-        :ensure  => 'file',
-        :source  => options[:source],
-        :require => "Notify[alpha]",
-        :before  => "Notify[omega]"
-      }
-      # The static compiler does not operate on a RAL catalog, so we're
-      # using Puppet::Resource to produce a resource catalog.
-      agnostic_path = File.expand_path("/tmp/file_#{idx}.txt") # Windows Friendly
-      rsrc = Puppet::Resource.new("file", agnostic_path, :parameters => parameters)
-      rsrc.file = 'site.pp'
-      rsrc.line = idx
-      resources << rsrc
-    end
-
-    resources.each do |rsrc|
-      catalog.add_resource(rsrc)
-    end
-
-    # Return the resource catalog
-    catalog
-  end
-
-  describe "(#22744) when filtering resources" do
-    let(:catalog) { stub_everything 'catalog' }
-
-    it "should delegate to the catalog instance filtering" do
-      catalog.expects(:filter)
-      subject.filter(catalog)
-    end
-
-    it "should filter out virtual resources" do
-      resource = mock 'resource', :virtual? => true
-      catalog.stubs(:filter).yields(resource)
-
-      subject.filter(catalog)
-    end
-
-    it "should return the same catalog if it doesn't support filtering" do
-      catalog.stubs(:respond_to?).with(:filter)
-      expect(subject.filter(catalog)).to eq(catalog)
-    end
-
-    it "should return the filtered catalog" do
-      filtered_catalog = stub 'filtered catalog'
-      catalog.stubs(:filter).returns(filtered_catalog)
-
-      expect(subject.filter(catalog)).to eq(filtered_catalog)
-    end
-
-  end
-
-  def fileserver_metadata(options = {})
-    yaml = <<EOFILESERVERMETADATA
---- !ruby/object:Puppet::FileServing::Metadata
-  checksum: "{md5}361fadf1c712e812d198c4cab5712a79"
-  checksum_type: md5
-  destination:
-  expiration: #{Time.now + 1800}
-  ftype: file
-  group: 0
-  links: !ruby/sym manage
-  mode: 420
-  owner: 0
-  path: #{File.expand_path('/etc/puppetlabs/code/modules/mymodule/files/config_file.txt')}
-  source: #{options[:source]}
-  stat_method: !ruby/sym lstat
-EOFILESERVERMETADATA
-    # Return a deserialized metadata object suitable for returning from a stub.
-    YAML.load(yaml)
-  end
-end
-