puppet 7.28.0-x86-mingw32 → 7.29.0-x86-mingw32

data/spec/unit/ssl/verifier_spec.rb

@@ -1,102 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::SSL::Verifier do
-  let(:options) { {} }
-  let(:ssl_context) { Puppet::SSL::SSLContext.new(options) }
-  let(:host) { 'example.com' }
-  let(:http) { Net::HTTP.new(host) }
-  let(:verifier) { described_class.new(host, ssl_context) }
-
-  context '#reusable?' do
-    it 'Verifiers with the same ssl_context are reusable' do
-      expect(verifier).to be_reusable(described_class.new(host, ssl_context))
-    end
-
-    it 'Verifiers with different ssl_contexts are not reusable' do
-      expect(verifier).to_not be_reusable(described_class.new(host, Puppet::SSL::SSLContext.new))
-    end
-  end
-
-  context '#setup_connection' do
-    it 'copies parameters from the ssl_context to the connection' do
-      store = double('store')
-      options.merge!(store: store)
-      verifier.setup_connection(http)
-
-      expect(http.cert_store).to eq(store)
-    end
-
-    it 'defaults to VERIFY_PEER' do
-      expect(http).to receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
-
-      verifier.setup_connection(http)
-    end
-
-    it 'only uses VERIFY_NONE if explicitly disabled' do
-      options.merge!(verify_peer: false)
-
-      expect(http).to receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
-
-      verifier.setup_connection(http)
-    end
-
-    it 'registers a verify callback' do
-      verifier.setup_connection(http)
-
-      expect(http.verify_callback).to eq(verifier)
-    end
-  end
-
-  context '#handle_connection_error' do
-    let(:peer_cert) { cert_fixture('127.0.0.1.pem') }
-    let(:chain) { [peer_cert] }
-    let(:ssl_error) { OpenSSL::SSL::SSLError.new("certificate verify failed") }
-
-    it "raises a verification error for a CA cert" do
-      store_context = double('store_context', current_cert: peer_cert, chain: [peer_cert], error: OpenSSL::X509::V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY, error_string: "unable to get local issuer certificate")
-      verifier.call(false, store_context)
-
-      expect {
-        verifier.handle_connection_error(http, ssl_error)
-      }.to raise_error(Puppet::SSL::CertVerifyError, "certificate verify failed [unable to get local issuer certificate for CN=127.0.0.1]")
-    end
-
-    it "raises a verification error for the server cert" do
-      store_context = double('store_context', current_cert: peer_cert, chain: chain, error: OpenSSL::X509::V_ERR_CERT_REJECTED, error_string: "certificate rejected")
-      verifier.call(false, store_context)
-
-      expect {
-        verifier.handle_connection_error(http, ssl_error)
-      }.to raise_error(Puppet::SSL::CertVerifyError, "certificate verify failed [certificate rejected for CN=127.0.0.1]")
-    end
-
-    it "raises cert mismatch error on ruby < 2.4" do
-      expect(http).to receive(:peer_cert).and_return(peer_cert)
-
-      store_context = double('store_context')
-      verifier.call(true, store_context)
-
-      ssl_error = OpenSSL::SSL::SSLError.new("hostname 'example'com' does not match the server certificate")
-
-      expect {
-        verifier.handle_connection_error(http, ssl_error)
-      }.to raise_error(Puppet::Error, "Server hostname 'example.com' did not match server certificate; expected one of 127.0.0.1, DNS:127.0.0.1, DNS:127.0.0.2")
-    end
-
-    it "raises cert mismatch error on ruby >= 2.4" do
-      store_context = double('store_context', current_cert: peer_cert, chain: chain, error: OpenSSL::X509::V_OK, error_string: "ok")
-      verifier.call(false, store_context)
-
-      expect {
-        verifier.handle_connection_error(http, ssl_error)
-      }.to raise_error(Puppet::Error, "Server hostname 'example.com' did not match server certificate; expected one of 127.0.0.1, DNS:127.0.0.1, DNS:127.0.0.2")
-    end
-
-    it 're-raises other ssl connection errors' do
-      err = OpenSSL::SSL::SSLError.new("This version of OpenSSL does not support FIPS mode")
-      expect {
-        verifier.handle_connection_error(http, err)
-      }.to raise_error(err)
-    end
-  end
-end

data/spec/unit/task_spec.rb

@@ -1,345 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/files'
-require 'puppet_spec/modules'
-require 'puppet/module/task'
-
-describe Puppet::Module::Task do
-  include PuppetSpec::Files
-
-  let(:modpath) { tmpdir('task_modpath') }
-  let(:mymodpath) { File.join(modpath, 'mymod') }
-  let(:othermodpath) { File.join(modpath, 'othermod') }
-  let(:mymod) { Puppet::Module.new('mymod', mymodpath, nil) }
-  let(:othermod) { Puppet::Module.new('othermod', othermodpath, nil) }
-  let(:tasks_path) { File.join(mymodpath, 'tasks') }
-  let(:other_tasks_path) { File.join(othermodpath, 'tasks') }
-  let(:tasks_glob) { File.join(mymodpath, 'tasks', '*') }
-
-  it "cannot construct tasks with illegal names" do
-    expect { Puppet::Module::Task.new(mymod, "iLegal", []) }
-      .to raise_error(Puppet::Module::Task::InvalidName,
-                      "Task names must start with a lowercase letter and be composed of only lowercase letters, numbers, and underscores")
-  end
-
-  it "constructs tasks as expected when every task has a metadata file with the same name (besides extension)" do
-    task_files = %w{task1.json task1 task2.json task2.exe task3.json task3.sh}.map { |bn| "#{tasks_path}/#{bn}" }
-    expect(Dir).to receive(:glob).with(tasks_glob).and_return(task_files)
-    task_files.each { |f| expect(File).to receive(:file?).with(f).and_return(true) }
-    tasks = Puppet::Module::Task.tasks_in_module(mymod)
-    allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({})
-
-    expect(tasks.count).to eq(3)
-    expect(tasks.map{|t| t.name}).to eq(%w{mymod::task1 mymod::task2 mymod::task3})
-    expect(tasks.map{|t| t.metadata_file}).to eq(["#{tasks_path}/task1.json",
-                                                  "#{tasks_path}/task2.json",
-                                                  "#{tasks_path}/task3.json"])
-    expect(tasks.map{|t| t.files.map { |f| f["path"] } }).to eq([["#{tasks_path}/task1"],
-                                                                 ["#{tasks_path}/task2.exe"],
-                                                                 ["#{tasks_path}/task3.sh"]])
-    expect(tasks.map{|t| t.files.map { |f| f["name"] } }).to eq([["task1"],
-                                                                 ["task2.exe"],
-                                                                 ["task3.sh"]])
-
-    tasks.map{|t| t.metadata_file}.each do |metadata_file|
-      expect(metadata_file).to eq(File.absolute_path(metadata_file))
-    end
-
-    tasks.map{|t| t.files}.each do |file_data|
-      path = file_data[0]['path']
-      expect(path).to eq(File.absolute_path(path))
-    end
-  end
-
-  it "constructs tasks as expected when some tasks don't have a metadata file" do
-    task_files = %w{task1 task2.exe task3.json task3.sh}.map { |bn| "#{tasks_path}/#{bn}" }
-    expect(Dir).to receive(:glob).with(tasks_glob).and_return(task_files)
-    task_files.each { |f| expect(File).to receive(:file?).with(f).and_return(true) }
-    allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({})
-    tasks = Puppet::Module::Task.tasks_in_module(mymod)
-
-    expect(tasks.count).to eq(3)
-    expect(tasks.map{|t| t.name}).to eq(%w{mymod::task1 mymod::task2 mymod::task3})
-    expect(tasks.map{|t| t.metadata_file}).to eq([nil, nil, "#{tasks_path}/task3.json"])
-    expect(tasks.map{|t| t.files.map { |f| f["path"] } }).to eq([["#{tasks_path}/task1"],
-                                          ["#{tasks_path}/task2.exe"],
-                                          ["#{tasks_path}/task3.sh"]])
-  end
-
-  it "constructs a task as expected when a task has implementations" do
-    task_files = %w{task1.elf task1.sh task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
-    expect(Dir).to receive(:glob).with(tasks_glob).and_return(task_files)
-    task_files.each { |f| expect(File).to receive(:file?).with(f).and_return(true) }
-    tasks = Puppet::Module::Task.tasks_in_module(mymod)
-    allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({'implementations' => [{"name" => "task1.sh"}]})
-
-    expect(tasks.count).to eq(1)
-    expect(tasks.map{|t| t.name}).to eq(%w{mymod::task1})
-    expect(tasks.map{|t| t.metadata_file}).to eq(["#{tasks_path}/task1.json"])
-    expect(tasks.map{|t| t.files.map{ |f| f["path"] } }).to eq([["#{tasks_path}/task1.sh"]])
-  end
-
-  it "constructs a task as expected when task metadata declares additional files" do
-    task_files = %w{task1.sh task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
-    expect(Dir).to receive(:glob).with(tasks_glob).and_return(task_files)
-    task_files.each { |f| expect(File).to receive(:file?).with(f).and_return(true) }
-    expect(Puppet::Module::Task).to receive(:find_extra_files).and_return([{'name' => 'mymod/lib/file0.elf', 'path' => "/path/to/file0.elf"}])
-    tasks = Puppet::Module::Task.tasks_in_module(mymod)
-    allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({'files' => ["mymod/lib/file0.elf"]})
-
-    expect(tasks.count).to eq(1)
-    expect(tasks.map{|t| t.name}).to eq(%w{mymod::task1})
-    expect(tasks.map{|t| t.metadata_file}).to eq(["#{tasks_path}/task1.json"])
-    expect(tasks.map{|t| t.files.map{ |f| f["path"] } }).to eq([["#{tasks_path}/task1.sh", "/path/to/file0.elf"]])
-  end
-
-  it "constructs a task as expected when a task implementation declares additional files" do
-    task_files = %w{task1.sh task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
-    expect(Dir).to receive(:glob).with(tasks_glob).and_return(task_files)
-    task_files.each { |f| expect(File).to receive(:file?).with(f).and_return(true) }
-    expect(Puppet::Module::Task).to receive(:find_extra_files).and_return([{'name' => 'mymod/lib/file0.elf', 'path' => "/path/to/file0.elf"}])
-    tasks = Puppet::Module::Task.tasks_in_module(mymod)
-    allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({'implementations' => [{"name" => "task1.sh", "files" => ["mymod/lib/file0.elf"]}]})
-
-    expect(tasks.count).to eq(1)
-    expect(tasks.map{|t| t.name}).to eq(%w{mymod::task1})
-    expect(tasks.map{|t| t.metadata_file}).to eq(["#{tasks_path}/task1.json"])
-    expect(tasks.map{|t| t.files.map{ |f| f["path"] } }).to eq([["#{tasks_path}/task1.sh", "/path/to/file0.elf"]])
-  end
-
-  it "constructs a task as expected when task metadata and a task implementation both declare additional files" do
-    task_files = %w{task1.sh task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
-    expect(Dir).to receive(:glob).with(tasks_glob).and_return(task_files)
-    task_files.each { |f| expect(File).to receive(:file?).with(f).and_return(true) }
-    expect(Puppet::Module::Task).to receive(:find_extra_files).and_return([
-      {'name' => 'mymod/lib/file0.elf', 'path' => "/path/to/file0.elf"},
-      {'name' => 'yourmod/files/file1.txt', 'path' => "/other/path/to/file1.txt"}
-    ])
-    tasks = Puppet::Module::Task.tasks_in_module(mymod)
-    allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({'implementations' => [{"name" => "task1.sh", "files" => ["mymod/lib/file0.elf"]}]})
-
-    expect(tasks.count).to eq(1)
-    expect(tasks.map{|t| t.name}).to eq(%w{mymod::task1})
-    expect(tasks.map{|t| t.metadata_file}).to eq(["#{tasks_path}/task1.json"])
-    expect(tasks.map{|t| t.files.map{ |f| f["path"] } }).to eq([[
-      "#{tasks_path}/task1.sh",
-      "/path/to/file0.elf",
-      "/other/path/to/file1.txt"
-    ]])
-  end
-
-  it "constructs a task as expected when a task has files" do
-    og_files = %w{task1.sh task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
-    expect(Dir).to receive(:glob).with(tasks_glob).and_return(og_files)
-    og_files.each { |f| expect(File).to receive(:file?).with(f).and_return(true) }
-    expect(File).to receive(:exist?).with(any_args).and_return(true).at_least(:once)
-
-    expect(Puppet::Module).to receive(:find).with(othermod.name, "production").and_return(othermod).at_least(:once)
-    short_files = %w{other_task.sh other_task.json task_2.sh}.map { |bn| "#{othermod.name}/tasks/#{bn}" }
-    long_files = %w{other_task.sh other_task.json task_2.sh}.map { |bn| "#{other_tasks_path}/#{bn}" }
-    tasks = Puppet::Module::Task.tasks_in_module(mymod)
-    allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({'files' => short_files})
-
-    expect(tasks.count).to eq(1)
-    expect(tasks.map{|t| t.files.map{ |f| f["path"] } }).to eq([["#{tasks_path}/task1.sh"] + long_files])
-  end
-
-  it "fails to load a task if its metadata specifies a non-existent file" do
-    og_files = %w{task1.sh task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
-    allow(Dir).to receive(:glob).with(tasks_glob).and_return(og_files)
-    og_files.each { |f| expect(File).to receive(:file?).with(f).and_return(true) }
-    allow(File).to receive(:exist?).with(any_args).and_return(true)
-
-    expect(Puppet::Module).to receive(:find).with(othermod.name, "production").and_return(nil).at_least(:once)
-    tasks = Puppet::Module::Task.tasks_in_module(mymod)
-    allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({'files' => ["#{othermod.name}/files/test"]})
-
-    expect { tasks.first.files }.to raise_error(Puppet::Module::Task::InvalidMetadata, /Could not find module #{othermod.name} containing task file test/)
-  end
-
-  it "finds files whose names (besides extensions) are valid task names" do
-    og_files = %w{task task_1 xx_t_a_s_k_2_xx}.map { |bn| "#{tasks_path}/#{bn}" }
-    expect(Dir).to receive(:glob).with(tasks_glob).and_return(og_files)
-    og_files.each { |f| expect(File).to receive(:file?).with(f).and_return(true) }
-    tasks = Puppet::Module::Task.tasks_in_module(mymod)
-
-    expect(tasks.count).to eq(3)
-    expect(tasks.map{|t| t.name}).to eq(%w{mymod::task mymod::task_1 mymod::xx_t_a_s_k_2_xx})
-  end
-
-  it "ignores files that have names (besides extensions) that are not valid task names" do
-    og_files = %w{.nottask.exe .wat !runme _task 2task2furious def_a_task_PSYCH Fake_task not-a-task realtask}.map { |bn| "#{tasks_path}/#{bn}" }
-    expect(Dir).to receive(:glob).with(tasks_glob).and_return(og_files)
-    og_files.each { |f| expect(File).to receive(:file?).with(f).and_return(true) }
-    tasks = Puppet::Module::Task.tasks_in_module(mymod)
-
-    expect(tasks.count).to eq(1)
-    expect(tasks.map{|t| t.name}).to eq(%w{mymod::realtask})
-  end
-
-  it "ignores files that have names ending in .conf and .md" do
-    og_files = %w{ginuwine_task task.conf readme.md other_task.md}.map { |bn| "#{tasks_path}/#{bn}" }
-    expect(Dir).to receive(:glob).with(tasks_glob).and_return(og_files)
-    og_files.each { |f| expect(File).to receive(:file?).with(f).and_return(true) }
-    tasks = Puppet::Module::Task.tasks_in_module(mymod)
-
-    expect(tasks.count).to eq(1)
-    expect(tasks.map{|t| t.name}).to eq(%w{mymod::ginuwine_task})
-  end
-
-  it "ignores files which are not regular files" do
-    og_files = %w{foo}.map { |bn| "#{tasks_path}/#{bn}" }
-    expect(Dir).to receive(:glob).with(tasks_glob).and_return(og_files)
-    og_files.each { |f| expect(File).to receive(:file?).with(f).and_return(false) }
-    tasks = Puppet::Module::Task.tasks_in_module(mymod)
-
-    expect(tasks.count).to eq(0)
-  end
-
-  it "gives the 'init' task a name that is just the module's name" do
-    expect(Puppet::Module::Task.new(mymod, 'init', ["#{tasks_path}/init.sh"]).name).to eq('mymod')
-  end
-
-  describe :metadata do
-    it "loads metadata for a task" do
-      metadata  = {'desciption': 'some info'}
-      og_files = %w{task1.exe task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
-      expect(Dir).to receive(:glob).with(tasks_glob).and_return(og_files)
-      og_files.each { |f| expect(File).to receive(:file?).with(f).and_return(true) }
-      allow(Puppet::Module::Task).to receive(:read_metadata).and_return(metadata)
-
-      tasks = Puppet::Module::Task.tasks_in_module(mymod)
-
-      expect(tasks.count).to eq(1)
-      expect(tasks[0].metadata).to eq(metadata)
-    end
-
-    it 'returns nil for metadata if no file is present' do
-      og_files = %w{task1.exe}.map { |bn| "#{tasks_path}/#{bn}" }
-      expect(Dir).to receive(:glob).with(tasks_glob).and_return(og_files)
-      og_files.each { |f| expect(File).to receive(:file?).with(f).and_return(true) }
-      tasks = Puppet::Module::Task.tasks_in_module(mymod)
-
-      expect(tasks.count).to eq(1)
-      expect(tasks[0].metadata).to be_nil
-    end
-
-    it 'raises InvalidMetadata if the json metadata is invalid' do
-      FileUtils.mkdir_p(tasks_path)
-      File.open(File.join(tasks_path, 'task.json'), 'w') { |f| f.write '{ "whoops"' }
-      FileUtils.touch(File.join(tasks_path, 'task'))
-
-      tasks = Puppet::Module::Task.tasks_in_module(mymod)
-      expect(tasks.count).to eq(1)
-
-      expect {
-        tasks[0].metadata
-      }.to raise_error(Puppet::Module::Task::InvalidMetadata, /whoops/)
-    end
-
-    it 'returns empty hash for metadata when json metadata file is empty' do
-      FileUtils.mkdir_p(tasks_path)
-      FileUtils.touch(File.join(tasks_path, 'task.json'))
-      FileUtils.touch(File.join(tasks_path, 'task'))
-
-      tasks = Puppet::Module::Task.tasks_in_module(mymod)
-
-      expect(tasks.count).to eq(1)
-      expect(tasks[0].metadata).to eq({})
-    end
-  end
-
-  describe :validate do
-    it "validates when there is no metadata" do
-      og_files = %w{task1.exe}.map { |bn| "#{tasks_path}/#{bn}" }
-      expect(Dir).to receive(:glob).with(tasks_glob).and_return(og_files)
-      og_files.each { |f| expect(File).to receive(:file?).with(f).and_return(true) }
-
-      tasks = Puppet::Module::Task.tasks_in_module(mymod)
-
-      expect(tasks.count).to eq(1)
-      expect(tasks[0].validate).to eq(true)
-    end
-
-    it "validates when an implementation isn't used" do
-      metadata  = {'desciption' => 'some info',
-        'implementations' => [ {"name" => "task1.exe"}, ] }
-      og_files = %w{task1.exe task1.sh task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
-      expect(Dir).to receive(:glob).with(tasks_glob).and_return(og_files)
-      og_files.each { |f| expect(File).to receive(:file?).with(f).and_return(true) }
-      allow(Puppet::Module::Task).to receive(:read_metadata).and_return(metadata)
-
-      tasks = Puppet::Module::Task.tasks_in_module(mymod)
-
-      expect(tasks.count).to eq(1)
-      expect(tasks[0].validate).to be(true)
-    end
-
-    it "validates when an implementation is another task" do
-      metadata  = {'desciption' => 'some info',
-                   'implementations' => [ {"name" => "task2.sh"}, ] }
-      og_files = %w{task1.exe task2.sh task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
-      expect(Dir).to receive(:glob).with(tasks_glob).and_return(og_files)
-      og_files.each { |f| expect(File).to receive(:file?).with(f).and_return(true) }
-      allow(Puppet::Module::Task).to receive(:read_metadata).and_return(metadata)
-
-      tasks = Puppet::Module::Task.tasks_in_module(mymod)
-
-      expect(tasks.count).to eq(2)
-      expect(tasks.map(&:validate)).to eq([true, true])
-    end
-
-    it "fails validation when there is no metadata and multiple task files" do
-      og_files = %w{task1.elf task1.exe task1.json task2.ps1 task2.sh}.map { |bn| "#{tasks_path}/#{bn}" }
-      expect(Dir).to receive(:glob).with(tasks_glob).and_return(og_files)
-      og_files.each { |f| expect(File).to receive(:file?).with(f).and_return(true) }
-      tasks = Puppet::Module::Task.tasks_in_module(mymod)
-      allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({})
-
-      tasks.each do |task|
-        expect {task.validate}.to raise_error(Puppet::Module::Task::InvalidTask)
-      end
-    end
-
-    it "fails validation when an implementation references a non-existant file" do
-      og_files = %w{task1.elf task1.exe task1.json}.map { |bn| "#{tasks_path}/#{bn}" }
-      expect(Dir).to receive(:glob).with(tasks_glob).and_return(og_files)
-      og_files.each { |f| expect(File).to receive(:file?).with(f).and_return(true) }
-      tasks = Puppet::Module::Task.tasks_in_module(mymod)
-      allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({'implementations' => [ { 'name' => 'task1.sh' } ] })
-
-      tasks.each do |task|
-        expect {task.validate}.to raise_error(Puppet::Module::Task::InvalidTask)
-      end
-    end
-
-    it 'fails validation when there is metadata but no executable' do
-      og_files = %w{task1.json task2.sh}.map { |bn| "#{tasks_path}/#{bn}" }
-      expect(Dir).to receive(:glob).with(tasks_glob).and_return(og_files)
-      og_files.each { |f| expect(File).to receive(:file?).with(f).and_return(true) }
-      tasks = Puppet::Module::Task.tasks_in_module(mymod)
-      allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({})
-
-      expect { tasks.find { |t| t.name == 'mymod::task1' }.validate }.to raise_error(Puppet::Module::Task::InvalidTask)
-    end
-
-    it 'fails validation when the implementations are not an array' do
-      og_files = %w{task1.json task2.sh}.map { |bn| "#{tasks_path}/#{bn}" }
-      expect(Dir).to receive(:glob).with(tasks_glob).and_return(og_files)
-      og_files.each { |f| expect(File).to receive(:file?).with(f).and_return(true) }
-      tasks = Puppet::Module::Task.tasks_in_module(mymod)
-      allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({"implemenations" => {}})
-
-      expect { tasks.find { |t| t.name == 'mymod::task1' }.validate }.to raise_error(Puppet::Module::Task::InvalidTask)
-    end
-
-    it 'fails validation when the implementation is json' do
-      og_files = %w{task1.json task1.sh}.map { |bn| "#{tasks_path}/#{bn}" }
-      expect(Dir).to receive(:glob).with(tasks_glob).and_return(og_files)
-      og_files.each { |f| expect(File).to receive(:file?).with(f).and_return(true) }
-      tasks = Puppet::Module::Task.tasks_in_module(mymod)
-      allow_any_instance_of(Puppet::Module::Task).to receive(:metadata).and_return({'implementations' => [ { 'name' => 'task1.json' } ] })
-
-      expect { tasks.find { |t| t.name == 'mymod::task1' }.validate }.to raise_error(Puppet::Module::Task::InvalidTask)
-    end
-  end
-end

data/spec/unit/test/test_helper_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe "TestHelper" do
-  context "#after_each_test" do
-    it "restores the original environment" do
-      varname = 'test_helper_spec-test_variable'
-      Puppet::Util.set_env(varname, "\u16A0")
-
-      expect(Puppet::Util.get_env(varname)).to eq("\u16A0")
-
-      # Prematurely trigger the after_each_test method
-      Puppet::Test::TestHelper.after_each_test
-
-      expect(Puppet::Util::get_env(varname)).to be_nil
-    end
-  end
-end