puppet 4.0.0 → 5.0.0

data/spec/integration/data_binding.rb

@@ -1,104 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/compiler'
-
-describe "Data binding" do
-  include PuppetSpec::Files
-  include PuppetSpec::Compiler
-
-  let(:dir) { tmpdir("puppetdir") }
-
-  before do
-    Puppet[:data_binding_terminus] = "hiera"
-    Puppet[:modulepath] = dir
-  end
-
-  it "looks up data from hiera" do
-    configure_hiera_for({
-      "testing::binding::value" => "the value",
-      "testing::binding::calling_class" => "%{calling_class}",
-      "testing::binding::calling_class_path" => "%{calling_class_path}",
-      "testing::binding::calling_module" => "%{calling_module}"
-     
-    })
-
-    create_manifest_in_module("testing", "binding.pp",
-                              <<-MANIFEST)
-    class testing::binding($value,
-                           $calling_class,
-                           $calling_class_path,
-                           $calling_module) {}
-    MANIFEST
-
-    catalog = compile_to_catalog("include testing::binding")
-    resource = catalog.resource('Class[testing::binding]')
-
-    expect(resource[:value]).to eq("the value")
-    expect(resource[:calling_class]).to eq("testing::binding")
-    expect(resource[:calling_class_path]).to eq("testing/binding")
-    expect(resource[:calling_module]).to eq("testing")
-  end
-
-  it "works with the puppet backend configured, although it can't use it for lookup" do
-    configure_hiera_for_puppet
-    create_manifest_in_module("testing", "binding.pp",
-                              <<-MANIFEST)
-    # lookup via the puppet backend to ensure it works
-    class testing::binding($value = hiera('variable')) {}
-    MANIFEST
-
-    create_manifest_in_module("testing", "data.pp",
-                              <<-MANIFEST)
-    class testing::data {
-      $variable = "the value"
-    }
-    MANIFEST
-
-    catalog = compile_to_catalog("include testing::binding")
-    resource = catalog.resource('Class[testing::binding]')
-
-    expect(resource[:value]).to eq("the value")
-  end
-
-  def configure_hiera_for(data)
-    hiera_config_file = tmpfile("hiera.yaml")
-
-    File.open(hiera_config_file, 'w') do |f|
-      f.write("---
-        :yaml:
-          :datadir: #{dir}
-        :hierarchy: ['global']
-        :logger: 'noop'
-        :backends: ['yaml']
-      ")
-    end
-
-    File.open(File.join(dir, 'global.yaml'), 'w') do |f|
-      f.write(YAML.dump(data))
-    end
-
-    Puppet[:hiera_config] = hiera_config_file
-  end
-
-  def configure_hiera_for_puppet
-    hiera_config_file = tmpfile("hiera.yaml")
-
-    File.open(hiera_config_file, 'w') do |f|
-      f.write("---
-        :logger: 'noop'
-        :backends: ['puppet']
-      ")
-    end
-
-    Puppet[:hiera_config] = hiera_config_file
-  end
-
-  def create_manifest_in_module(module_name, name, manifest)
-    module_dir = File.join(dir, module_name, 'manifests')
-    FileUtils.mkdir_p(module_dir)
-
-    File.open(File.join(module_dir, name), 'w') do |f|
-      f.write(manifest)
-    end
-  end
-end

data/spec/integration/parser/functions/require_spec.rb

@@ -1,43 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-describe "The require function" do
-  before :each do
-    @node = Puppet::Node.new("mynode")
-    @compiler = Puppet::Parser::Compiler.new(@node)
-
-    @compiler.send(:evaluate_main)
-    @compiler.catalog.client_version = "0.25"
-    @scope = @compiler.topscope
-    # preload our functions
-    Puppet::Parser::Functions.function(:include)
-    Puppet::Parser::Functions.function(:require)
-  end
-
-  it "should add a dependency between the 'required' class and our class" do
-    @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "requiredclass")
-
-    @scope.function_require(["requiredclass"])
-    expect(@scope.resource["require"]).not_to be_nil
-    ref = @scope.resource["require"].shift
-    expect(ref.type).to eq("Class")
-    expect(ref.title).to eq("Requiredclass")
-  end
-
-  it "should queue relationships between the 'required' class and our classes" do
-    @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "requiredclass1")
-    @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "requiredclass2")
-
-    @scope.function_require(["requiredclass1"])
-    @scope.function_require(["requiredclass2"])
-
-    expect(@scope.resource["require"]).not_to be_nil
-
-    (ref1,ref2) = @scope.resource["require"]
-    expect(ref1.type).to eq("Class")
-    expect(ref1.title).to eq("Requiredclass1")
-    expect(ref2.type).to eq("Class")
-    expect(ref2.title).to eq("Requiredclass2")
-  end
-
-end

data/spec/integration/provider/package_spec.rb

@@ -1,33 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-describe "Package provider" do
-  include PuppetSpec::Files
-
-  Puppet::Type.type(:package).providers.each do |name|
-    provider = Puppet::Type.type(:package).provider(name)
-
-    describe name, :if => provider.suitable? do
-      it "should fail when asked to install an invalid package" do
-        options = {:name => "nosuch#{provider.name}", :provider => provider.name}
-
-        pkg = Puppet::Type.newpackage(options)
-        expect { pkg.provider.install }.to raise_error
-      end
-
-      it "should be able to get a list of existing packages" do
-        # the instances method requires root priviledges on gentoo
-        # if the eix cache is outdated (to run eix-update) so make
-        # sure we dont actually run eix-update
-        if provider.name == :portage
-          provider.stubs(:update_eix).returns('Database contains 15240 packages in 155 categories')
-        end
-
-        provider.instances.each do |package|
-          expect(package).to be_instance_of(provider)
-          expect(package.properties[:provider]).to eq(provider.name)
-        end
-      end
-    end
-  end
-end

data/spec/unit/application/inspect_spec.rb

@@ -1,287 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-require 'puppet/application/inspect'
-require 'puppet/resource/catalog'
-require 'puppet/indirector/catalog/yaml'
-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
-  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::Yaml.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::Yaml.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::Yaml.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::Yaml.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::Yaml.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::Yaml.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
-
-          expect(@report.logs.first).not_to eq(nil)
-          expect(@report.logs.first.message).to match(/Could not back up/)
-        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::Yaml.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/sample_data_provider_spec.rb

@@ -1,52 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-require 'puppet_spec/compiler'
-
-describe "when using a sample data provider from an external module" do
-  include PuppetSpec::Compiler
-
-  # There is a fully configured 'sample' environment in fixtures at this location
-  let(:environmentpath) { parent_fixture('environments') }
-
-  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
-    node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}), :environment => 'sample')
-    compiler = Puppet::Parser::Compiler.new(node)
-    catalog = compiler.compile()
-    resources_created_in_fixture = ["Notify[env data param_a is 10, env data param_b is 20, 3]"]
-    expect(resources_in(catalog)).to include(*resources_created_in_fixture)
-  end
-
-  it 'the module and environment data loader is used to set parameters' do
-    node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}), :environment => 'sample')
-    compiler = Puppet::Parser::Compiler.new(node)
-    catalog = compiler.compile()
-    resources_created_in_fixture = ["Notify[module data param_a is 100, module data param_b is 200, env data param_c is 300]"]
-    expect(resources_in(catalog)).to include(*resources_created_in_fixture)
-  end
-
-  def parent_fixture(dir_name)
-    File.absolute_path(File.join(my_fixture_dir(), "../#{dir_name}"))
-  end
-
-  def resources_in(catalog)
-    catalog.resources.map(&:ref)
-  end
-
-end

data/spec/unit/face/file_spec.rb

@@ -1,10 +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
-end