RubyGems - puppet - Versions diffs - 7.28.0-universal-darwin → 7.29.0-universal-darwin - Mend

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

Files changed (1257) hide show

data/spec/integration/http/client_spec.rb DELETED Viewed

@@ -1,229 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/https'
-require 'puppet_spec/files'
-describe Puppet::HTTP::Client, unless: Puppet::Util::Platform.jruby? do
-  include PuppetSpec::Files
-  include_context "https client"
-  let(:wrong_hostname) { 'localhost' }
-  let(:client) { Puppet::HTTP::Client.new }
-  let(:ssl_provider) { Puppet::SSL::SSLProvider.new }
-  let(:root_context) { ssl_provider.create_root_context(cacerts: [https_server.ca_cert], crls: [https_server.ca_crl]) }
-  context "when verifying an HTTPS server" do
-    it "connects over SSL" do
-      https_server.start_server do |port|
-        res = client.get(URI("https://127.0.0.1:#{port}"), options: {ssl_context: root_context})
-        expect(res).to be_success
-      end
-    end
-    it "raises connection error if we can't connect" do
-      Puppet[:http_connect_timeout] = '0s'
-      # get available port, but don't bind to it
-      tcps = TCPServer.new("127.0.0.1", 0)
-      port = tcps.connect_address.ip_port
-      expect {
-        client.get(URI("https://127.0.0.1:#{port}"), options: {ssl_context: root_context})
-      }.to raise_error(Puppet::HTTP::ConnectionError, %r{^Request to https://127.0.0.1:#{port} timed out connect operation after .* seconds})
-    end
-    it "raises if the server's cert doesn't match the hostname we connected to" do
-      https_server.start_server do |port|
-        expect {
-          client.get(URI("https://#{wrong_hostname}:#{port}"), options: {ssl_context: root_context})
-        }.to raise_error { |err|
-          expect(err).to be_instance_of(Puppet::SSL::CertMismatchError)
-          expect(err.message).to match(/Server hostname '#{wrong_hostname}' did not match server certificate; expected one of (.+)/)
-          md = err.message.match(/expected one of (.+)/)
-          expect(md[1].split(', ')).to contain_exactly('127.0.0.1', 'DNS:127.0.0.1', 'DNS:127.0.0.2')
-        }
-      end
-    end
-    it "raises if the server's CA is unknown" do
-      wrong_ca = cert_fixture('netlock-arany-utf8.pem')
-      alt_context = ssl_provider.create_root_context(cacerts: [wrong_ca], revocation: false)
-      https_server.start_server do |port|
-        expect {
-          client.get(URI("https://127.0.0.1:#{port}"), options: {ssl_context: alt_context})
-        }.to raise_error(Puppet::SSL::CertVerifyError,
-                         %r{certificate verify failed.* .self signed certificate in certificate chain for CN=Test CA.})
-      end
-    end
-    it "prints TLS protocol and ciphersuite in debug" do
-      Puppet[:log_level] = 'debug'
-      https_server.start_server do |port|
-        client.get(URI("https://127.0.0.1:#{port}"), options: {ssl_context: root_context})
-        # TLS version string can be TLSv1 or TLSv1.[1-3], but not TLSv1.0
-        expect(@logs).to include(
-          an_object_having_attributes(level: :debug, message: /Using TLSv1(\.[1-3])? with cipher .*/),
-        )
-      end
-    end
-  end
-  context "with client certs" do
-    let(:ctx_proc) {
-      -> ctx {
-        # configures the server to require the client to present a client cert
-        ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER | OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
-      }
-    }
-    let(:cert_file) do
-      res = tmpfile('cert_file')
-      File.write(res, https_server.ca_cert)
-      res
-    end
-    it "mutually authenticates the connection using an explicit context" do
-      client_context = ssl_provider.create_context(
-        cacerts: [https_server.ca_cert], crls: [https_server.ca_crl],
-        client_cert: https_server.server_cert, private_key: https_server.server_key
-      )
-      https_server.start_server(ctx_proc: ctx_proc) do |port|
-        res = client.get(URI("https://127.0.0.1:#{port}"), options: {ssl_context: client_context})
-        expect(res).to be_success
-      end
-    end
-    it "mutually authenticates the connection when the client and server certs are issued from different CAs" do
-      # this is the client cert's CA, key and cert
-      Puppet[:localcacert] = fixtures('ssl/unknown-ca.pem')
-      Puppet[:hostprivkey] = fixtures('ssl/unknown-127.0.0.1-key.pem')
-      Puppet[:hostcert] = fixtures('ssl/unknown-127.0.0.1.pem')
-      # this is the server cert's CA that the client needs in order to authenticate the server
-      Puppet[:ssl_trust_store] = fixtures('ssl/ca.pem')
-      # need to pass both the client and server CAs. The former is needed so the server can authenticate our client cert
-      https_server = PuppetSpec::HTTPSServer.new(ca_cert: [cert_fixture('ca.pem'), cert_fixture('unknown-ca.pem')])
-      https_server.start_server(ctx_proc: ctx_proc) do |port|
-        res = client.get(URI("https://127.0.0.1:#{port}"), options: {include_system_store: true})
-        expect(res).to be_success
-      end
-    end
-    it "connects when the server's CA is in the system store and the connection is mutually authenticated using create_context" do
-      Puppet::Util.withenv("SSL_CERT_FILE" => cert_file) do
-        client_context = ssl_provider.create_context(
-          cacerts: [], crls: [],
-          client_cert: https_server.server_cert, private_key: https_server.server_key,
-          revocation: false, include_system_store: true
-        )
-        https_server.start_server(ctx_proc: ctx_proc) do |port|
-          res = client.get(URI("https://127.0.0.1:#{port}"), options: {ssl_context: client_context})
-          expect(res).to be_success
-        end
-      end
-    end
-    it "connects when the server's CA is in the system store and the connection is mutually authenticated using load_context" do
-      Puppet::Util.withenv("SSL_CERT_FILE" => cert_file) do
-        client_context = ssl_provider.load_context(revocation: false, include_system_store: true)
-        https_server.start_server(ctx_proc: ctx_proc) do |port|
-          res = client.get(URI("https://127.0.0.1:#{port}"), options: {ssl_context: client_context})
-          expect(res).to be_success
-        end
-      end
-    end
-  end
-  context "with a system trust store" do
-    it "connects when the client trusts the server's CA" do
-      system_context = ssl_provider.create_system_context(cacerts: [https_server.ca_cert])
-      https_server.start_server do |port|
-        res = client.get(URI("https://127.0.0.1:#{port}"), options: {ssl_context: system_context})
-        expect(res).to be_success
-      end
-    end
-    it "connects when the server's CA is in the system store" do
-      # create a temp cacert bundle
-      cert_file = tmpfile('cert_file')
-      File.write(cert_file, https_server.ca_cert)
-      # override path to system cacert bundle, this must be done before
-      # the SSLContext is created and the call to X509::Store.set_default_paths
-      Puppet::Util.withenv("SSL_CERT_FILE" => cert_file) do
-        system_context = ssl_provider.create_system_context(cacerts: [])
-        https_server.start_server do |port|
-          res = client.get(URI("https://127.0.0.1:#{port}"), options: {ssl_context: system_context})
-          expect(res).to be_success
-        end
-      end
-    end
-    it "raises if the server's CA is not in the context or system store" do
-      system_context = ssl_provider.create_system_context(cacerts: [cert_fixture('netlock-arany-utf8.pem')])
-      https_server.start_server do |port|
-        expect {
-          client.get(URI("https://127.0.0.1:#{port}"), options: {ssl_context: system_context})
-        }.to raise_error(Puppet::SSL::CertVerifyError,
-                         %r{certificate verify failed.* .self signed certificate in certificate chain for CN=Test CA.})
-      end
-    end
-  end
-  context 'ensure that retrying does not attempt to read the body after closing the connection' do
-    let(:client) { Puppet::HTTP::Client.new(retry_limit: 1) }
-    it 'raises a retry error instead' do
-      response_proc = -> (req, res) {
-        res['Retry-After'] = 1
-        res.status = 503
-      }
-      https_server.start_server(response_proc: response_proc) do |port|
-        uri = URI("https://127.0.0.1:#{port}")
-        kwargs = {headers: {'Content-Type' => 'text/plain'}, options: {ssl_context: root_context}}
-        expect{client.post(uri, '', **kwargs)}.to raise_error(Puppet::HTTP::TooManyRetryAfters)
-      end
-    end
-  end
-  context 'persistent connections' do
-    it "detects when the server has closed the connection and reconnects" do
-      Puppet[:http_debug] = true
-      # advertise that we support keep-alive, but we don't really
-      response_proc = -> (req, res) {
-        res['Connection'] = 'Keep-Alive'
-      }
-      https_server.start_server(response_proc: response_proc) do |port|
-        uri = URI("https://127.0.0.1:#{port}")
-        kwargs = {headers: {'Content-Type' => 'text/plain'}, options: {ssl_context: root_context}}
-        expect {
-          expect(client.post(uri, '', **kwargs)).to be_success
-          # the server closes its connection after each request, so posting
-          # again will force ruby to detect that the remote side closed the
-          # connection, and reconnect
-          expect(client.post(uri, '', **kwargs)).to be_success
-        }.to output(/Conn close because of EOF/).to_stderr
-      end
-    end
-  end
-  context 'ciphersuites' do
-    it "does not connect when using an SSLv3 ciphersuite", :if => Puppet::Util::Package.versioncmp(OpenSSL::OPENSSL_LIBRARY_VERSION.split[1], '1.1.1e') > 0 do
-      Puppet[:ciphers] = "DES-CBC3-SHA"
-      https_server.start_server do |port|
-        expect {
-          client.get(URI("https://127.0.0.1:#{port}"), options: {ssl_context: root_context})
-        }.to raise_error(Puppet::HTTP::ConnectionError, /no cipher match|sslv3 alert handshake failure/)
-      end
-    end
-  end
-end

data/spec/integration/indirector/catalog/compiler_spec.rb DELETED Viewed

@@ -1,75 +0,0 @@
-require 'spec_helper'
-require 'puppet/resource/catalog'
-Puppet::Resource::Catalog.indirection.terminus(:compiler)
-describe Puppet::Resource::Catalog::Compiler do
-  before do
-    allow(Facter).to receive(:value).and_return("something")
-    @catalog = Puppet::Resource::Catalog.new("testing", Puppet::Node::Environment::NONE)
-    @catalog.add_resource(@one = Puppet::Resource.new(:file, "/one"))
-    @catalog.add_resource(@two = Puppet::Resource.new(:file, "/two"))
-  end
-  it "should remove virtual resources when filtering" do
-    @one.virtual = true
-    expect(Puppet::Resource::Catalog.indirection.terminus.filter(@catalog).resource_refs).to eq([ @two.ref ])
-  end
-  it "should not remove exported resources when filtering" do
-    @one.exported = true
-    expect(Puppet::Resource::Catalog.indirection.terminus.filter(@catalog).resource_refs.sort).to eq([ @one.ref, @two.ref ])
-  end
-  it "should remove virtual exported resources when filtering" do
-    @one.exported = true
-    @one.virtual = true
-    expect(Puppet::Resource::Catalog.indirection.terminus.filter(@catalog).resource_refs).to eq([ @two.ref ])
-  end
-  it "should filter out virtual resources when finding a catalog" do
-    Puppet[:node_terminus] = :memory
-    Puppet::Node.indirection.save(Puppet::Node.new("mynode"))
-    allow(Puppet::Resource::Catalog.indirection.terminus).to receive(:extract_facts_from_request)
-    allow(Puppet::Resource::Catalog.indirection.terminus).to receive(:compile).and_return(@catalog)
-    @one.virtual = true
-    expect(Puppet::Resource::Catalog.indirection.find("mynode").resource_refs).to eq([ @two.ref ])
-  end
-  it "should not filter out exported resources when finding a catalog" do
-    Puppet[:node_terminus] = :memory
-    Puppet::Node.indirection.save(Puppet::Node.new("mynode"))
-    allow(Puppet::Resource::Catalog.indirection.terminus).to receive(:extract_facts_from_request)
-    allow(Puppet::Resource::Catalog.indirection.terminus).to receive(:compile).and_return(@catalog)
-    @one.exported = true
-    expect(Puppet::Resource::Catalog.indirection.find("mynode").resource_refs.sort).to eq([ @one.ref, @two.ref ])
-  end
-  it "should filter out virtual exported resources when finding a catalog" do
-    Puppet[:node_terminus] = :memory
-    Puppet::Node.indirection.save(Puppet::Node.new("mynode"))
-    allow(Puppet::Resource::Catalog.indirection.terminus).to receive(:extract_facts_from_request)
-    allow(Puppet::Resource::Catalog.indirection.terminus).to receive(:compile).and_return(@catalog)
-    @one.exported = true
-    @one.virtual = true
-    expect(Puppet::Resource::Catalog.indirection.find("mynode").resource_refs).to eq([ @two.ref ])
-  end
-  it "filters out virtual exported resources using the agent's production environment" do
-    Puppet[:node_terminus] = :memory
-    Puppet::Node.indirection.save(Puppet::Node.new("mynode"))
-    catalog_environment = nil
-    expect_any_instance_of(Puppet::Parser::Resource::Catalog).to receive(:to_resource) {catalog_environment = Puppet.lookup(:current_environment).name}
-    Puppet::Resource::Catalog.indirection.find("mynode")
-    expect(catalog_environment).to eq(:production)
-  end
-end

data/spec/integration/indirector/direct_file_server_spec.rb DELETED Viewed

@@ -1,90 +0,0 @@
-require 'spec_helper'
-require 'puppet/indirector/file_content/file'
-require 'puppet/indirector/file_metadata/file'
-describe Puppet::Indirector::DirectFileServer, " when interacting with the filesystem and the model" do
-  include PuppetSpec::Files
-  before do
-    # We just test a subclass, since it's close enough.
-    @terminus = Puppet::Indirector::FileContent::File.new
-  end
-  it "should return an instance of the model" do
-    filepath = make_absolute("/path/to/my/file")
-    expect(Puppet::FileSystem).to receive(:exist?).with(filepath).and_return(true)
-    expect(@terminus.find(@terminus.indirection.request(:find, Puppet::Util.path_to_uri(filepath).to_s, nil))).to be_instance_of(Puppet::FileServing::Content)
-  end
-  it "should return an instance capable of returning its content" do
-    filename = file_containing("testfile", "my content")
-    instance = @terminus.find(@terminus.indirection.request(:find, Puppet::Util.path_to_uri(filename).to_s, nil))
-    expect(instance.content).to eq("my content")
-  end
-end
-describe Puppet::Indirector::DirectFileServer, " when interacting with FileServing::Fileset and the model" do
-  include PuppetSpec::Files
-  matcher :file_with_content do |name, content|
-    match do |actual|
-      actual.full_path == name && actual.content == content
-    end
-  end
-  matcher :directory_named do |name|
-    match do |actual|
-      actual.full_path == name
-    end
-  end
-  it "should return an instance for every file in the fileset" do
-    path = tmpdir('direct_file_server_testing')
-    File.open(File.join(path, "one"), "w") { |f| f.print "one content" }
-    File.open(File.join(path, "two"), "w") { |f| f.print "two content" }
-    terminus = Puppet::Indirector::FileContent::File.new
-    request = terminus.indirection.request(:search, Puppet::Util.path_to_uri(path).to_s, nil, :recurse => true)
-    expect(terminus.search(request)).to contain_exactly(
-      file_with_content(File.join(path, "one"), "one content"),
-      file_with_content(File.join(path, "two"), "two content"),
-      directory_named(path))
-  end
-end
-describe Puppet::Indirector::DirectFileServer, " when interacting with filesystem metadata" do
-  include PuppetSpec::Files
-  include_context 'with supported checksum types'
-  before do
-    @terminus = Puppet::Indirector::FileMetadata::File.new
-  end
-  with_checksum_types("file_metadata", "testfile") do
-    it "should return the correct metadata" do
-      request = @terminus.indirection.request(:find, Puppet::Util.path_to_uri(checksum_file).to_s, nil, :checksum_type => checksum_type)
-      result = @terminus.find(request)
-      expect_correct_checksum(result, checksum_type, checksum, Puppet::FileServing::Metadata)
-    end
-  end
-  with_checksum_types("direct_file_server_testing", "testfile") do
-    it "search of FileServing::Fileset should return the correct metadata" do
-      request = @terminus.indirection.request(:search, Puppet::Util.path_to_uri(env_path).to_s, nil, :recurse => true, :checksum_type => checksum_type)
-      result = @terminus.search(request)
-      expect(result).to_not be_nil
-      expect(result.length).to eq(2)
-      file, dir = result.partition {|x| x.relative_path == 'testfile'}
-      expect(file.length).to eq(1)
-      expect(dir.length).to eq(1)
-      expect_correct_checksum(dir[0], 'ctime', "#{CHECKSUM_STAT_TIME}", Puppet::FileServing::Metadata)
-      expect_correct_checksum(file[0], checksum_type, checksum, Puppet::FileServing::Metadata)
-    end
-  end
-end

data/spec/integration/indirector/facts/facter_spec.rb DELETED Viewed

@@ -1,168 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/files'
-require 'puppet_spec/compiler'
-require 'puppet/indirector/facts/facter'
-describe Puppet::Node::Facts::Facter do
-  include PuppetSpec::Files
-  include PuppetSpec::Compiler
-  include PuppetSpec::Settings
-  before :each do
-    Puppet::Node::Facts.indirection.terminus_class = :facter
-  end
-  it "preserves case in fact values" do
-    Puppet.runtime[:facter].add(:downcase_test) do
-      setcode do
-        "AaBbCc"
-      end
-    end
-    allow(Facter).to receive(:reset)
-    cat = compile_to_catalog('notify { $downcase_test: }',
-                             Puppet::Node.indirection.find('foo'))
-    expect(cat.resource("Notify[AaBbCc]")).to be
-  end
-  context "resolving file based facts" do
-    let(:factdir) { tmpdir('factdir') }
-    it "should resolve custom facts" do
-      test_module = File.join(factdir, 'module', 'lib', 'facter')
-      FileUtils.mkdir_p(test_module)
-      File.open(File.join(test_module, 'custom.rb'), 'wb') { |file| file.write(<<-EOF)}
-      Puppet.runtime[:facter].add(:custom) do
-        setcode do
-          Puppet.runtime[:facter].value('puppetversion')
-        end
-      end
-      EOF
-      Puppet.initialize_settings(['--modulepath', factdir])
-      apply = Puppet::Application.find(:apply).new(double('command_line', :subcommand_name => :apply, :args => ['--modulepath', factdir, '-e', 'notify { $custom: }']))
-      expect {
-        apply.run
-      }.to exit_with(0)
-       .and output(/defined 'message' as '#{Puppet.version}'/).to_stdout
-    end
-    it "should resolve external facts" do
-      external_fact = File.join(factdir, 'external.json')
-      File.open(external_fact, 'wb') { |file| file.write(<<-EOF)}
-        {"foo": "bar"}
-        EOF
-      Puppet.initialize_settings(['--pluginfactdest', factdir])
-      apply = Puppet::Application.find(:apply).new(double('command_line', :subcommand_name => :apply, :args => ['--pluginfactdest', factdir, '-e', 'notify { $foo: }']))
-      expect {
-        apply.run
-      }.to exit_with(0)
-       .and output(/defined 'message' as 'bar'/).to_stdout
-    end
-  end
-  context "adding facts" do
-    it "adds the puppetversion fact" do
-      allow(Facter).to receive(:reset)
-      cat = compile_to_catalog('notify { $::puppetversion: }',
-                               Puppet::Node.indirection.find('foo'))
-      expect(cat.resource("Notify[#{Puppet.version.to_s}]")).to be
-    end
-    context "when adding the agent_specified_environment fact" do
-      it "does not add the fact if the agent environment is not set" do
-        expect do
-          compile_to_catalog('notify { $::agent_specified_environment: }',
-                             Puppet::Node.indirection.find('foo'))
-        end.to raise_error(Puppet::PreformattedError)
-      end
-      it "does not add the fact if the agent environment is set in sections other than agent or main" do
-        set_puppet_conf(Puppet[:confdir], <<~CONF)
-        [user]
-        environment=bar
-        CONF
-        Puppet.initialize_settings
-        expect do
-          compile_to_catalog('notify { $::agent_specified_environment: }',
-                             Puppet::Node.indirection.find('foo'))
-        end.to raise_error(Puppet::PreformattedError)
-      end
-      it "adds the agent_specified_environment fact when set in the agent section in puppet.conf" do
-        set_puppet_conf(Puppet[:confdir], <<~CONF)
-        [agent]
-        environment=bar
-        CONF
-        Puppet.initialize_settings
-        cat = compile_to_catalog('notify { $::agent_specified_environment: }',
-                                 Puppet::Node.indirection.find('foo'))
-        expect(cat.resource("Notify[bar]")).to be
-      end
-      it "prefers agent_specified_environment from main if set in section other than agent" do
-        set_puppet_conf(Puppet[:confdir], <<~CONF)
-        [main]
-        environment=baz
-        [user]
-        environment=bar
-        CONF
-        Puppet.initialize_settings
-        cat = compile_to_catalog('notify { $::agent_specified_environment: }',
-                                 Puppet::Node.indirection.find('foo'))
-        expect(cat.resource("Notify[baz]")).to be
-      end
-      it "prefers agent_specified_environment from agent if set in multiple sections" do
-        set_puppet_conf(Puppet[:confdir], <<~CONF)
-        [main]
-        environment=baz
-        [agent]
-        environment=bar
-        CONF
-        Puppet.initialize_settings
-        cat = compile_to_catalog('notify { $::agent_specified_environment: }',
-                                 Puppet::Node.indirection.find('foo'))
-        expect(cat.resource("Notify[bar]")).to be
-      end
-      it "adds the agent_specified_environment fact when set in puppet.conf" do
-        set_puppet_conf(Puppet[:confdir], 'environment=bar')
-        Puppet.initialize_settings
-        cat = compile_to_catalog('notify { $::agent_specified_environment: }',
-                                 Puppet::Node.indirection.find('foo'))
-        expect(cat.resource("Notify[bar]")).to be
-      end
-      it "adds the agent_specified_environment fact when set via command-line" do
-        Puppet.initialize_settings(['--environment', 'bar'])
-        cat = compile_to_catalog('notify { $::agent_specified_environment: }',
-                                 Puppet::Node.indirection.find('foo'))
-        expect(cat.resource("Notify[bar]")).to be
-      end
-      it "adds the agent_specified_environment fact, preferring cli, when set in puppet.conf and via command-line" do
-        set_puppet_conf(Puppet[:confdir], 'environment=bar')
-        Puppet.initialize_settings(['--environment', 'baz'])
-        cat = compile_to_catalog('notify { $::agent_specified_environment: }',
-                                 Puppet::Node.indirection.find('foo'))
-        expect(cat.resource("Notify[baz]")).to be
-      end
-    end
-  end
-end

data/spec/integration/indirector/file_content/file_server_spec.rb DELETED Viewed

@@ -1,106 +0,0 @@
-require 'spec_helper'
-require 'puppet/indirector/file_content/file_server'
-require 'shared_behaviours/file_server_terminus'
-require 'puppet_spec/files'
-describe Puppet::Indirector::FileContent::FileServer, " when finding files" do
-  it_should_behave_like "Puppet::Indirector::FileServerTerminus"
-  include PuppetSpec::Files
-  before do
-    @terminus = Puppet::Indirector::FileContent::FileServer.new
-    @test_class = Puppet::FileServing::Content
-    Puppet::FileServing::Configuration.instance_variable_set(:@configuration, nil)
-  end
-  it "should find plugin file content in the environment specified in the request" do
-    path = tmpfile("file_content_with_env")
-    Dir.mkdir(path)
-    modpath = File.join(path, "mod")
-    FileUtils.mkdir_p(File.join(modpath, "lib"))
-    file = File.join(modpath, "lib", "file.rb")
-    File.open(file, "wb") { |f| f.write "1\r\n" }
-    Puppet.settings[:modulepath] = "/no/such/file"
-    env = Puppet::Node::Environment.create(:foo, [path])
-    result = Puppet::FileServing::Content.indirection.search("plugins", :environment => env, :recurse => true)
-    expect(result).not_to be_nil
-    expect(result.length).to eq(2)
-    result.map {|x| expect(x).to be_instance_of(Puppet::FileServing::Content) }
-    expect(result.find {|x| x.relative_path == 'file.rb' }.content).to eq("1\r\n")
-  end
-  it "should find file content in modules" do
-    path = tmpfile("file_content")
-    Dir.mkdir(path)
-    modpath = File.join(path, "mymod")
-    FileUtils.mkdir_p(File.join(modpath, "files"))
-    file = File.join(modpath, "files", "myfile")
-    File.open(file, "wb") { |f| f.write "1\r\n" }
-    env = Puppet::Node::Environment.create(:foo, [path])
-    result = Puppet::FileServing::Content.indirection.find("modules/mymod/myfile", :environment => env)
-    expect(result).not_to be_nil
-    expect(result).to be_instance_of(Puppet::FileServing::Content)
-    expect(result.content).to eq("1\r\n")
-  end
-  it "should find file content of tasks in modules" do
-    path = tmpfile("task_file_content")
-    Dir.mkdir(path)
-    modpath = File.join(path, "myothermod")
-    FileUtils.mkdir_p(File.join(modpath, "tasks"))
-    file = File.join(modpath, "tasks", "mytask")
-    File.open(file, "wb") { |f| f.write "I'm a task" }
-    env = Puppet::Node::Environment.create(:foo, [path])
-    result = Puppet::FileServing::Content.indirection.find("tasks/myothermod/mytask", :environment => env)
-    expect(result).not_to be_nil
-    expect(result).to be_instance_of(Puppet::FileServing::Content)
-    expect(result.content).to eq("I'm a task")
-  end
-  it "should find file content in files when node name expansions are used" do
-    allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-    allow(Puppet::FileSystem).to receive(:exist?).with(Puppet[:fileserverconfig]).and_return(true)
-    path = tmpfile("file_server_testing")
-    Dir.mkdir(path)
-    subdir = File.join(path, "mynode")
-    Dir.mkdir(subdir)
-    File.open(File.join(subdir, "myfile"), "wb") { |f| f.write "1\r\n" }
-    # Use a real mount, so the integration is a bit deeper.
-    mount1 = Puppet::FileServing::Configuration::Mount::File.new("one")
-    mount1.path = File.join(path, "%h")
-    parser = double('parser', :changed? => false)
-    allow(parser).to receive(:parse).and_return("one" => mount1)
-    allow(Puppet::FileServing::Configuration::Parser).to receive(:new).and_return(parser)
-    path = File.join(path, "myfile")
-    env = Puppet::Node::Environment.create(:foo, [])
-    result = Puppet::FileServing::Content.indirection.find("one/myfile", :environment => env, :node => "mynode")
-    expect(result).not_to be_nil
-    expect(result).to be_instance_of(Puppet::FileServing::Content)
-    expect(result.content).to eq("1\r\n")
-  end
-end