puppet 4.10.12-universal-darwin → 5.0.0-universal-darwin

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
-

data/spec/unit/indirector/resource_type/parser_spec.rb

@@ -1,259 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-require 'puppet/indirector/resource_type/parser'
-require 'puppet_spec/files'
-
-describe Puppet::Indirector::ResourceType::Parser do
-  include PuppetSpec::Files
-
-  let(:environmentpath) { tmpdir("envs") }
-  let(:modulepath) { "#{environmentpath}/test/modules" }
-  let(:environment) { Puppet::Node::Environment.create(:test, [modulepath]) }
-  before do
-    @terminus = Puppet::Indirector::ResourceType::Parser.new
-    @request = Puppet::Indirector::Request.new(:resource_type, :find, "foo", nil)
-    @request.environment = environment
-    @krt = @request.environment.known_resource_types
-  end
-
-  it "should be registered with the resource_type indirection" do
-    expect(Puppet::Indirector::Terminus.terminus_class(:resource_type, :parser)).to equal(Puppet::Indirector::ResourceType::Parser)
-  end
-
-  it "is deprecated on the network, but still allows requests" do
-    Puppet.expects(:deprecation_warning)
-    expect(Puppet::Indirector::ResourceType::Parser.new.allow_remote_requests?).to eq(true)
-  end
-
-  describe "when finding" do
-    it "should return any found type from the request's environment" do
-      type = Puppet::Resource::Type.new(:hostclass, "foo")
-      @request.environment.known_resource_types.add(type)
-
-      expect(@terminus.find(@request)).to eq(type)
-    end
-
-    it "should attempt to load the type if none is found in memory" do
-      FileUtils.mkdir_p(modulepath)
-
-      # Make a new request, since we've reset the env
-      request = Puppet::Indirector::Request.new(:resource_type, :find, "foo::bar", nil)
-      request.environment = environment
-
-      manifest_path = File.join(modulepath, "foo", "manifests")
-      FileUtils.mkdir_p(manifest_path)
-
-      File.open(File.join(manifest_path, "bar.pp"), "w") { |f| f.puts "class foo::bar {}" }
-
-      result = @terminus.find(request)
-      expect(result).to be_instance_of(Puppet::Resource::Type)
-      expect(result.name).to eq("foo::bar")
-    end
-
-    it "should return nil if no type can be found" do
-      expect(@terminus.find(@request)).to be_nil
-    end
-
-    it "should prefer definitions to nodes" do
-      type = @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
-      node = @krt.add(Puppet::Resource::Type.new(:node, "foo"))
-
-      expect(@terminus.find(@request)).to eq(type)
-    end
-  end
-
-  describe "when searching" do
-    describe "when the search key is a wildcard" do
-      before do
-        @request.key = "*"
-      end
-
-      it "should use the request's environment's list of known resource types" do
-        @request.environment.known_resource_types.expects(:hostclasses).returns({})
-
-        @terminus.search(@request)
-      end
-
-      it "should return all results if '*' is provided as the search string" do
-        type = @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
-        node = @krt.add(Puppet::Resource::Type.new(:node, "bar"))
-        define = @krt.add(Puppet::Resource::Type.new(:definition, "baz"))
-
-        result = @terminus.search(@request)
-        expect(result).to be_include(type)
-        expect(result).to be_include(node)
-        expect(result).to be_include(define)
-      end
-
-      it "should return all known types" do
-        type = @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
-        node = @krt.add(Puppet::Resource::Type.new(:node, "bar"))
-        define = @krt.add(Puppet::Resource::Type.new(:definition, "baz"))
-
-        result = @terminus.search(@request)
-        expect(result).to be_include(type)
-        expect(result).to be_include(node)
-        expect(result).to be_include(define)
-      end
-
-      it "should not return the 'main' class" do
-        main = @krt.add(Puppet::Resource::Type.new(:hostclass, ""))
-
-        # So there is a return value
-        foo = @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
-
-        expect(@terminus.search(@request)).not_to be_include(main)
-      end
-
-      it "should return nil if no types can be found" do
-        expect(@terminus.search(@request)).to be_nil
-      end
-
-      it "should load all resource types from all search paths" do
-        dir = tmpdir("searching_in_all")
-        first = File.join(dir, "first")
-        second = File.join(dir, "second")
-        FileUtils.mkdir_p(first)
-        FileUtils.mkdir_p(second)
-        environment = Puppet::Node::Environment.create(:test, [first, second])
-
-        # Make a new request, since we've reset the env
-        request = Puppet::Indirector::Request.new(:resource_type, :search, "*", nil)
-        request.environment = environment
-
-        onepath = File.join(first, "one", "manifests")
-        FileUtils.mkdir_p(onepath)
-        twopath = File.join(first, "two", "manifests")
-        FileUtils.mkdir_p(twopath)
-
-        File.open(File.join(onepath, "oneklass.pp"), "w") { |f| f.puts "class one::oneklass {}" }
-        File.open(File.join(twopath, "twoklass.pp"), "w") { |f| f.puts "class two::twoklass {}" }
-
-        result = @terminus.search(request)
-        expect(result.find { |t| t.name == "one::oneklass" }).to be_instance_of(Puppet::Resource::Type)
-        expect(result.find { |t| t.name == "two::twoklass" }).to be_instance_of(Puppet::Resource::Type)
-      end
-
-      context "when specifying a 'kind' parameter" do
-        before :each do
-          @klass = @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
-          @node = @krt.add(Puppet::Resource::Type.new(:node, "bar"))
-          @define = @krt.add(Puppet::Resource::Type.new(:definition, "baz"))
-        end
-
-        it "should raise an error if you pass an invalid kind filter" do
-          @request.options[:kind] = "i bet you don't have a kind called this"
-          expect {
-            @terminus.search(@request)
-          }.to raise_error(ArgumentError, /Unrecognized kind filter/)
-
-        end
-
-        it "should support filtering for only hostclass results" do
-          @request.options[:kind] = "class"
-
-          result = @terminus.search(@request)
-          expect(result).to be_include(@klass)
-          expect(result).not_to be_include(@node)
-          expect(result).not_to be_include(@define)
-        end
-
-        it "should support filtering for only node results" do
-          @request.options[:kind] = "node"
-
-          result = @terminus.search(@request)
-          expect(result).not_to be_include(@klass)
-          expect(result).to be_include(@node)
-          expect(result).not_to be_include(@define)
-        end
-
-        it "should support filtering for only definition results" do
-          @request.options[:kind] = "defined_type"
-
-          result = @terminus.search(@request)
-          expect(result).not_to be_include(@klass)
-          expect(result).not_to be_include(@node)
-          expect(result).to be_include(@define)
-        end
-      end
-    end
-
-    context "when the search string is not a wildcard" do
-
-      it "should treat any search string as a regex" do
-        @request.key = "a"
-        foo = @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
-        bar = @krt.add(Puppet::Resource::Type.new(:hostclass, "bar"))
-        baz = @krt.add(Puppet::Resource::Type.new(:hostclass, "baz"))
-
-        result = @terminus.search(@request)
-        expect(result).to be_include(bar)
-        expect(result).to be_include(baz)
-        expect(result).not_to be_include(foo)
-      end
-
-      it "should support kind filtering with a regex" do
-        @request.key = "foo"
-        @request.options[:kind] = "class"
-
-        foobar = @krt.add(Puppet::Resource::Type.new(:hostclass, "foobar"))
-        foobaz = @krt.add(Puppet::Resource::Type.new(:hostclass, "foobaz"))
-        foobam = @krt.add(Puppet::Resource::Type.new(:definition, "foobam"))
-        fooball = @krt.add(Puppet::Resource::Type.new(:node, "fooball"))
-
-        result = @terminus.search(@request)
-        expect(result).to be_include(foobar)
-        expect(result).to be_include(foobaz)
-        expect(result).not_to be_include(foobam)
-        expect(result).not_to be_include(fooball)
-      end
-
-      it "should fail if a provided search string is not a valid regex" do
-        @request.key = "*foo*"
-
-        # Add one instance so we don't just get an empty array"
-        @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
-        expect { @terminus.search(@request) }.to raise_error(ArgumentError)
-      end
-    end
-
-    it "should not return the 'main' class" do
-      main = @krt.add(Puppet::Resource::Type.new(:hostclass, ""))
-
-      # So there is a return value
-      foo = @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
-
-      expect(@terminus.search(@request)).not_to be_include(main)
-    end
-
-    it "should return nil if no types can be found" do
-      expect(@terminus.search(@request)).to be_nil
-    end
-
-    it "should load all resource types from all search paths" do
-      dir = tmpdir("searching_in_all")
-      first = File.join(dir, "first")
-      second = File.join(dir, "second")
-      FileUtils.mkdir_p(first)
-      FileUtils.mkdir_p(second)
-      environment = Puppet::Node::Environment.create(:test, [first,second])
-
-      # Make a new request, since we've reset the env
-      request = Puppet::Indirector::Request.new(:resource_type, :search, "*", nil)
-      request.environment = environment
-
-      onepath = File.join(first, "one", "manifests")
-      FileUtils.mkdir_p(onepath)
-      twopath = File.join(first, "two", "manifests")
-      FileUtils.mkdir_p(twopath)
-
-      File.open(File.join(onepath, "oneklass.pp"), "w") { |f| f.puts "class one::oneklass {}" }
-      File.open(File.join(twopath, "twoklass.pp"), "w") { |f| f.puts "class two::twoklass {}" }
-
-      result = @terminus.search(request)
-      expect(result.find { |t| t.name == "one::oneklass" }).to be_instance_of(Puppet::Resource::Type)
-      expect(result.find { |t| t.name == "two::twoklass" }).to be_instance_of(Puppet::Resource::Type)
-    end
-  end
-end