puppet 5.0.0 → 6.0.0

data/spec/integration/parser/collection_spec.rb

@@ -180,7 +180,7 @@ describe 'collectors' do
     it "does not collect classes" do
       node = Puppet::Node.new('the node')
       expect do
-        catalog = compile_to_catalog(<<-MANIFEST, node)
+        compile_to_catalog(<<-MANIFEST, node)
           class theclass {
             @notify { "testing": message => "good message" }
           }
@@ -192,7 +192,7 @@ describe 'collectors' do
     it "does not collect resources that don't exist" do
       node = Puppet::Node.new('the node')
       expect do
-        catalog = compile_to_catalog(<<-MANIFEST, node)
+        compile_to_catalog(<<-MANIFEST, node)
           class theclass {
             @notify { "testing": message => "good message" }
           }
@@ -312,7 +312,46 @@ describe 'collectors' do
         MANIFEST
       end
 
+      context 'when overriding an already evaluated resource' do
+        let(:logs) { [] }
+        let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
+        let(:manifest) { <<-MANIFEST }
+          define foo($message) {
+            notify { "testing": message => $message }
+          }
+          foo { test: message => 'given' }
+          define delayed {
+            Foo <|  |> { message => 'overridden' }
+          }
+          delayed {'do it now': }
+        MANIFEST
+
+        around(:each) do |example|
+          Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+            example.run
+          end
+        end
+
+        it 'and --strict=off, it silently skips the override' do
+          Puppet[:strict] = :off
+          expect_the_message_to_be(['given'], manifest)
+          expect(warnings).to be_empty
+        end
+
+        it 'and --strict=warning, it warns about the attempt to override and skips it' do
+          Puppet[:strict] = :warning
+          expect_the_message_to_be(['given'], manifest)
+          expect(warnings).to include(
+            /Attempt to override an already evaluated resource, defined at \(line: 4\), with new values \(line: 6\)/)
+        end
+
+        it 'and --strict=error, it fails compilation' do
+          Puppet[:strict] = :error
+          expect { compile_to_catalog(manifest) }.to raise_error(
+            /Attempt to override an already evaluated resource, defined at \(line: 4\), with new values \(line: 6\)/)
+          expect(warnings).to be_empty
+        end
+      end
     end
   end
-
 end

data/spec/integration/parser/compiler_spec.rb

@@ -211,7 +211,7 @@ describe Puppet::Parser::Compiler do
   describe "the compiler when using 4.x language constructs" do
     include PuppetSpec::Compiler
 
-    if Puppet.features.microsoft_windows?
+    if Puppet::Util::Platform.windows?
       it "should be able to determine the configuration version from a local version control repository" do
         pending("Bug #14071 about semantics of Puppet::Util::Execute on Windows")
         # This should always work, because we should always be
@@ -259,7 +259,7 @@ describe Puppet::Parser::Compiler do
     it "should not create duplicate resources when a class is referenced both directly and indirectly by the node classifier (4792)" do
       node = Puppet::Node.new("testnodex")
       node.classes = ['foo', 'bar']
-      catalog = compile_to_catalog(<<-PP, node)
+      compile_to_catalog(<<-PP, node)
         class foo
         {
           notify { foo_notify: }
@@ -401,7 +401,7 @@ describe Puppet::Parser::Compiler do
 
       it "should not favor local name scope" do
         expect {
-          catalog = compile_to_catalog(<<-PP)
+          compile_to_catalog(<<-PP)
             class experiment {
               class baz {
               }
@@ -483,13 +483,6 @@ describe Puppet::Parser::Compiler do
     end
 
     describe "relationships to non existing resources (even with strict==off)" do
-      # At some point in the future, this test can be modified to simply ignore the strict flag,
-      # but since the current version is a change from being under control of strict, this is now
-      # explicit - the standard setting is strict == warning, here setting it to off
-      #
-      before(:each) do
-        Puppet[:strict] = :off
-      end
 
       [ 'before',
         'subscribe',
@@ -520,6 +513,15 @@ describe Puppet::Parser::Compiler do
           PP
         }.to raise_error(/Could not find resource 'Notify\[tooth_fairy\]' in parameter 'require'/)
       end
+
+      it 'faulty references are reported with source location' do
+        expect { 
+          compile_to_catalog(<<-PP)
+            notify{ x : 
+              require => tooth_fairy }
+          PP
+        }.to raise_error(/"tooth_fairy" is not a valid resource reference.*\(line: 2\)/)
+      end
     end
 
     describe "relationships can be formed" do
@@ -683,7 +685,7 @@ describe Puppet::Parser::Compiler do
 
       it 'an initial underscore in not ok if elsewhere than last segment' do
         expect do
-          catalog = compile_to_catalog(<<-MANIFEST)
+          compile_to_catalog(<<-MANIFEST)
             class a { $_a = 10}
             include a
             notify { 'test': message => $_a::_a }
@@ -769,7 +771,7 @@ describe Puppet::Parser::Compiler do
 
       it 'accepts anything when parameters are untyped' do
         expect do
-          catalog = compile_to_catalog(<<-MANIFEST)
+          compile_to_catalog(<<-MANIFEST)
           define foo($a, $b, $c) { }
           foo { 'test': a => String, b=>10, c=>undef }
           MANIFEST
@@ -778,7 +780,7 @@ describe Puppet::Parser::Compiler do
 
       it 'denies non type compliant arguments' do
         expect do
-          catalog = compile_to_catalog(<<-MANIFEST)
+          compile_to_catalog(<<-MANIFEST)
             define foo(Integer $x) { }
             foo { 'test': x =>'say friend' }
           MANIFEST
@@ -787,7 +789,7 @@ describe Puppet::Parser::Compiler do
 
       it 'denies undef for a non-optional type' do
         expect do
-          catalog = compile_to_catalog(<<-MANIFEST)
+          compile_to_catalog(<<-MANIFEST)
             define foo(Integer $x) { }
             foo { 'test': x => undef }
           MANIFEST
@@ -796,7 +798,7 @@ describe Puppet::Parser::Compiler do
 
       it 'denies non type compliant default argument' do
         expect do
-          catalog = compile_to_catalog(<<-MANIFEST)
+          compile_to_catalog(<<-MANIFEST)
             define foo(Integer $x = 'pow') { }
             foo { 'test':  }
           MANIFEST
@@ -805,7 +807,7 @@ describe Puppet::Parser::Compiler do
 
       it 'denies undef as the default for a non-optional type' do
         expect do
-          catalog = compile_to_catalog(<<-MANIFEST)
+          compile_to_catalog(<<-MANIFEST)
             define foo(Integer $x = undef) { }
             foo { 'test':  }
           MANIFEST
@@ -826,7 +828,7 @@ describe Puppet::Parser::Compiler do
 
       it 'uses infer_set when reporting type mismatch' do
         expect do
-          catalog = compile_to_catalog(<<-MANIFEST)
+          compile_to_catalog(<<-MANIFEST)
             define foo(Struct[{b => Integer, d=>String}] $a) { }
             foo{ bar: a => {b => 5, c => 'stuff'}}
           MANIFEST
@@ -855,7 +857,7 @@ describe Puppet::Parser::Compiler do
 
       it 'accepts anything when parameters are untyped' do
         expect do
-          catalog = compile_to_catalog(<<-MANIFEST)
+          compile_to_catalog(<<-MANIFEST)
             class foo($a, $b, $c) { }
             class { 'foo': a => String, b=>10, c=>undef }
           MANIFEST
@@ -864,7 +866,7 @@ describe Puppet::Parser::Compiler do
 
       it 'denies non type compliant arguments' do
         expect do
-          catalog = compile_to_catalog(<<-MANIFEST)
+          compile_to_catalog(<<-MANIFEST)
             class foo(Integer $x) { }
             class { 'foo': x =>'say friend' }
           MANIFEST
@@ -873,7 +875,7 @@ describe Puppet::Parser::Compiler do
 
       it 'denies undef for a non-optional type' do
         expect do
-          catalog = compile_to_catalog(<<-MANIFEST)
+          compile_to_catalog(<<-MANIFEST)
             class foo(Integer $x) { }
             class { 'foo': x => undef }
           MANIFEST
@@ -882,7 +884,7 @@ describe Puppet::Parser::Compiler do
 
       it 'denies non type compliant default argument' do
         expect do
-          catalog = compile_to_catalog(<<-MANIFEST)
+          compile_to_catalog(<<-MANIFEST)
             class foo(Integer $x = 'pow') { }
             class { 'foo':  }
           MANIFEST
@@ -891,13 +893,31 @@ describe Puppet::Parser::Compiler do
 
       it 'denies undef as the default for a non-optional type' do
         expect do
-          catalog = compile_to_catalog(<<-MANIFEST)
+          compile_to_catalog(<<-MANIFEST)
             class foo(Integer $x = undef) { }
             class { 'foo':  }
           MANIFEST
         end.to raise_error(/Class\[Foo\]: parameter 'x' expects an Integer value, got Undef/)
       end
 
+      it 'denies a regexp (rich data) argument given to class String parameter (even if later encoding of it is a string)' do
+        expect do
+          compile_to_catalog(<<-MANIFEST)
+            class foo(String $x) { }
+            class { 'foo':  x => /I am a regexp and I don't want to be a String/}
+          MANIFEST
+        end.to raise_error(/Class\[Foo\]: parameter 'x' expects a String value, got Regexp/)
+      end
+
+      it 'denies a regexp (rich data) argument given to define String parameter (even if later encoding of it is a string)' do
+        expect do
+          compile_to_catalog(<<-MANIFEST)
+            define foo(String $x) { }
+            foo { 'foo':  x => /I am a regexp and I don't want to be a String/}
+          MANIFEST
+        end.to raise_error(/Foo\[foo\]: parameter 'x' expects a String value, got Regexp/)
+      end
+
       it 'accepts a Resource as a Type' do
         catalog = compile_to_catalog(<<-MANIFEST)
           define bar($text) { }
@@ -1144,7 +1164,7 @@ describe Puppet::Parser::Compiler do
     it 'errors when an alias cannot be found when relationship is formed with -> operator' do
       node = Puppet::Node.new("testnodex")
       expect {
-        catalog = compile_to_catalog(<<-PP, node)
+        compile_to_catalog(<<-PP, node)
           notify { 'actual_2':  }
           notify { 'actual_1': alias => 'alias_1' }
           Notify[actual_2] -> Notify[alias_2]
@@ -1172,7 +1192,6 @@ describe Puppet::Parser::Compiler do
         include foo
         include bar
       MANIFEST
-      package = catalog.resource('Package', 'pip')
       expect(catalog.resource('Package', 'pip')[:require].to_s).to eql('Package[python]')
     end
 

data/spec/integration/parser/pcore_resource_spec.rb

@@ -219,7 +219,7 @@ describe 'when pcore described resources types are in use' do
       generate_and_in_a_compilers_context do |compiler|
         t1 = find_resource_type(compiler.topscope, 'test1')
         expect(t1.title_patterns.size).to be(1)
-        expect(t1.title_patterns[0][0]).to eql(/(.*)/m)
+        expect(t1.title_patterns[0][0]).to eql(/(?m-ix:(.*))/)
       end
     end
 
@@ -227,7 +227,7 @@ describe 'when pcore described resources types are in use' do
       pending "assertion of parameter types not yet implemented"
       genface.types
       expect {
-      catalog = compile_to_catalog(<<-MANIFEST)
+      compile_to_catalog(<<-MANIFEST)
         test2 { 'b':
           color => 'white is not a color'
         }
@@ -237,7 +237,7 @@ describe 'when pcore described resources types are in use' do
   end
 
   def find_resource_type(scope, name)
-    t1 = Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(scope, name)
+    Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(scope, name)
   end
 
   def generate_and_in_a_compilers_context(&block)

data/spec/integration/parser/scope_spec.rb

@@ -20,7 +20,7 @@ describe "Two step scoping for variables" do
   describe "using unsupported operators" do
     it "issues an error for +=" do
       expect do
-        catalog = compile_to_catalog(<<-MANIFEST)
+        compile_to_catalog(<<-MANIFEST)
               $var = ["top_msg"]
               node default {
                 $var += ["override"]
@@ -31,7 +31,7 @@ describe "Two step scoping for variables" do
 
     it "issues an error for -=" do
       expect do
-        catalog = compile_to_catalog(<<-MANIFEST)
+        compile_to_catalog(<<-MANIFEST)
               $var = ["top_msg"]
               node default {
                 $var -= ["top_msg"]
@@ -47,7 +47,7 @@ describe "Two step scoping for variables" do
           compile_to_catalog("$name = 'never in a 0xF4240 years'", enc_node)
         }.to raise_error(
           Puppet::Error,
-          /Cannot reassign built in \(or already assigned\) variable '\$name' at line 1(\:7)? on node the_node/
+          /Cannot reassign built in \(or already assigned\) variable '\$name' \(line: 1(, column: 7)?\) on node the_node/
         )
     end
 
@@ -58,7 +58,7 @@ describe "Two step scoping for variables" do
           compile_to_catalog("$title = 'never in a 0xF4240 years'", enc_node)
         }.to raise_error(
           Puppet::Error,
-          /Cannot reassign built in \(or already assigned\) variable '\$title' at line 1(\:8)? on node the_node/
+          /Cannot reassign built in \(or already assigned\) variable '\$title' \(line: 1(, column: 8)?\) on node the_node/
         )
     end
 
@@ -316,6 +316,19 @@ describe "Two step scoping for variables" do
       end
     end
 
+    it 'resolves a qualified name in class parameter scope' do
+      expect_the_message_to_be('Does it work? Yes!') do <<-PUPPET
+        class a ( 
+          $var1 = 'Does it work?',
+          $var2 = "${a::var1} Yes!"
+        ) { 
+          notify { 'something': message => $var2 }
+        }
+        include a
+        PUPPET
+      end
+    end
+
     it "finds values in its inherited scope when the inherited class is qualified to the top" do
       expect_the_message_to_be('foo_msg') do <<-MANIFEST
             node default {
@@ -682,7 +695,7 @@ describe "Two step scoping for variables" do
         compile_to_catalog("$var = 'top scope'", enc_node)
       }.to raise_error(
         Puppet::Error,
-        /Cannot reassign variable '\$var' at line 1(\:6)? on node the_node/
+        /Cannot reassign variable '\$var' \(line: 1(, column: 6)?\) on node the_node/
       )
     end
 

data/spec/integration/parser/script_compiler_spec.rb

@@ -0,0 +1,113 @@
+require 'puppet'
+require 'spec_helper'
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+require 'puppet/parser/script_compiler'
+
+describe 'the script compiler' do
+  include PuppetSpec::Compiler
+  include PuppetSpec::Files
+  include Matchers::Resource
+  before(:each) do
+    Puppet[:tasks] = true
+  end
+
+  context "when used" do
+    let(:env_name) { 'testenv' }
+    let(:environments_dir) { Puppet[:environmentpath] }
+    let(:env_dir) { File.join(environments_dir, env_name) }
+    let(:manifest) { Puppet::Node::Environment::NO_MANIFEST }
+    let(:env) { Puppet::Node::Environment.create(env_name.to_sym, [File.join(populated_env_dir, 'modules')], manifest) }
+    let(:node) { Puppet::Node.new("test", :environment => env) }
+
+    let(:env_dir_files) {
+      {
+        'manifests' => {
+          'good.pp' => "'good'\n"
+        },
+        'modules' => {
+          'test' => {
+            'plans' => {
+               'run_me.pp' => 'plan test::run_me() { "worked2" }'
+            }
+          }
+        }
+      }
+    }
+
+    let(:populated_env_dir) do
+      dir_contained_in(environments_dir, env_name => env_dir_files)
+      PuppetSpec::Files.record_tmp(env_dir)
+      env_dir
+    end
+
+    let(:script_compiler) do
+      Puppet::Parser::ScriptCompiler.new(env, node.name)
+    end
+
+    context 'is configured such that' do
+      it 'returns what the script_compiler returns' do
+        Puppet[:code] = <<-CODE
+            42
+          CODE
+        expect(script_compiler.compile).to eql(42)
+      end
+
+      it 'referencing undefined variables raises an error' do
+        expect do
+          Puppet[:code] = <<-CODE
+              notice $rubyversion
+            CODE
+            Puppet::Parser::ScriptCompiler.new(env, 'test_node_name').compile
+
+        end.to raise_error(/Unknown variable: 'rubyversion'/)
+      end
+
+      it 'has strict=error behavior' do
+        expect do
+          Puppet[:code] = <<-CODE
+              notice({a => 10, a => 20})
+            CODE
+            Puppet::Parser::ScriptCompiler.new(env, 'test_node_name').compile
+
+        end.to raise_error(/The key 'a' is declared more than once/)
+      end
+
+      it 'performing a multi assign from a class reference raises an error' do
+        expect do
+          Puppet[:code] = <<-CODE
+              [$a] = Class[the_dalit]
+            CODE
+            Puppet::Parser::ScriptCompiler.new(env, 'test_node_name').compile
+
+        end.to raise_error(/The catalog operation 'multi var assignment from class' is only available when compiling a catalog/)
+      end
+    end
+
+    context 'when using environment manifest' do
+      context 'set to single file' do
+        let (:manifest) { "#{env_dir}/manifests/good.pp" }
+
+        it 'loads and evaluates' do
+          expect(script_compiler.compile).to eql('good')
+        end
+      end
+
+      context 'set to directory' do
+        let (:manifest) { "#{env_dir}/manifests" }
+
+        it 'fails with an error' do
+          expect{script_compiler.compile}.to raise_error(/manifest of environment 'testenv' appoints directory '.*\/manifests'. It must be a file/)
+        end
+      end
+
+      context 'set to non existing path' do
+        let (:manifest) { "#{env_dir}/manyfiests/good.pp" }
+
+        it 'fails with an error' do
+          expect{script_compiler.compile}.to raise_error(/manifest of environment 'testenv' appoints '.*\/good.pp'. It does not exist/)
+        end
+      end
+    end
+  end
+end

data/spec/integration/provider/service/init_spec.rb

@@ -1,9 +1,11 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
-provider = Puppet::Type.type(:service).provider(:init)
+test_title = 'Integration Tests for Puppet::Type::Service::Provider::Init'
+
+describe test_title, unless: Puppet::Util::Platform.jruby? do
+  let(:provider) { Puppet::Type.type(:service).provider(:init) }
 
-describe provider do
   describe "when running on FreeBSD" do
     before :each do
       Facter.stubs(:value).with(:operatingsystem).returns 'FreeBSD'

data/spec/integration/provider/service/systemd_spec.rb

@@ -2,19 +2,23 @@
 
 require 'spec_helper'
 
-describe Puppet::Type.type(:service).provider(:systemd), '(integration)' do
+test_title = 'Integration Tests for Puppet::Type::Service::Provider::Systemd'
+
+describe test_title, unless: Puppet::Util::Platform.jruby? do
+  let(:provider_class) { Puppet::Type.type(:service).provider(:systemd) }
+
   # TODO: Unfortunately there does not seem a way to stub the executable
   #       checks in the systemd provider because they happen at load time.
   it "should be considered suitable if /bin/systemctl is present", :if => File.executable?('/bin/systemctl') do
-    expect(described_class).to be_suitable
+    expect(provider_class).to be_suitable
   end
 
   it "should be considered suitable if /usr/bin/systemctl is present", :if => File.executable?('/usr/bin/systemctl')  do
-    expect(described_class).to be_suitable
+    expect(provider_class).to be_suitable
   end
 
   it "should not be cosidered suitable if systemctl is absent",
     :unless => (File.executable?('/bin/systemctl') or File.executable?('/usr/bin/systemctl')) do
-    expect(described_class).not_to be_suitable
+    expect(provider_class).not_to be_suitable
   end
 end

data/spec/integration/provider/service/windows_spec.rb

@@ -1,13 +1,15 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
-describe Puppet::Type.type(:service).provider(:windows), '(integration)',
-  :if => Puppet.features.microsoft_windows? do
+test_title = 'Integration Tests for Puppet::Type::Service::Provider::Windows'
+
+describe test_title, '(integration)', :if => Puppet::Util::Platform.windows? do
+  let(:provider_class) { Puppet::Type.type(:service).provider(:windows) }
 
   require 'puppet/util/windows'
 
   before :each do
-    Puppet::Type.type(:service).stubs(:defaultprovider).returns described_class
+    Puppet::Type.type(:service).stubs(:defaultprovider).returns provider_class
   end
 
   context 'should fail querying services that do not exist' do

data/spec/integration/reference/providers_spec.rb

@@ -11,6 +11,12 @@ describe reference do
   end
 
   it "should be able to be rendered as markdown" do
+    # We have a :confine block that calls execute in our upstart provider, which fails
+    # on jruby. Thus, we stub it out here since we don't care to do any assertions on it.
+    # This is only an issue if you're running these unit tests on a platform where upstart
+    # is a default provider, like Ubuntu trusty.
+    Puppet::Util::Execution.stubs(:execute)
+
     reference.to_markdown
   end
 end

data/spec/integration/ssl/certificate_request_spec.rb

@@ -13,8 +13,6 @@ describe Puppet::SSL::CertificateRequest do
     Puppet.settings[:confdir] = dir
     Puppet.settings[:vardir] = dir
 
-    Puppet::SSL::Host.ca_location = :none
-
     @csr = Puppet::SSL::CertificateRequest.new("luke.madstop.com")
 
     @key = OpenSSL::PKey::RSA.new(512)

data/spec/integration/ssl/host_spec.rb

@@ -1,9 +1,10 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'puppet/test_ca'
 
 require 'puppet/ssl/host'
 
-describe Puppet::SSL::Host do
+describe Puppet::SSL::Host, if: !Puppet::Util::Platform.jruby? do
   include PuppetSpec::Files
 
   before do
@@ -12,19 +13,18 @@ describe Puppet::SSL::Host do
 
     Puppet.settings[:confdir] = dir
     Puppet.settings[:vardir] = dir
-
-    Puppet::SSL::Host.ca_location = :local
+    Puppet.settings.use :main, :ssl
 
     @host = Puppet::SSL::Host.new("luke.madstop.com")
-    @ca = Puppet::SSL::CertificateAuthority.new
-  end
-
-  after {
-    Puppet::SSL::Host.ca_location = :none
-  }
+    @host.stubs(:submit_certificate_request)
 
-  it "should be considered a CA host if its name is equal to 'ca'" do
-    expect(Puppet::SSL::Host.new(Puppet::SSL::CA_NAME)).to be_ca
+    @ca = Puppet::TestCa.new
+    Puppet::Util.replace_file(Puppet[:localcacert], 0644) do |f|
+      f.write(@ca.ca_cert.to_s)
+    end
+    Puppet::Util.replace_file(Puppet[:hostcrl], 0644) do |f|
+      f.write(@ca.ca_crl.to_s)
+    end
   end
 
   describe "when managing its key" do
@@ -61,20 +61,12 @@ describe Puppet::SSL::Host do
     end
   end
 
-  describe "when the CA host" do
-    it "should never store its key in the :privatekeydir" do
-      Puppet.settings.use(:main, :ssl, :ca)
-      @ca = Puppet::SSL::Host.new(Puppet::SSL::Host.ca_name)
-      @ca.generate_key
-
-      expect(Puppet::FileSystem.exist?(File.join(Puppet[:privatekeydir], "ca.pem"))).to be_falsey
-    end
-  end
-
   it "should pass the verification of its own SSL store", :unless => Puppet.features.microsoft_windows? do
-    @host.generate
-    @ca = Puppet::SSL::CertificateAuthority.new
-    @ca.sign(@host.name)
+    @host.generate_certificate_request
+    cert = @ca.sign(@host.certificate_request.content)
+    Puppet::Util.replace_file(File.join(Puppet[:certdir], "#{@host.name}.pem"), 0644) do |f|
+      f.write(cert)
+    end
 
     expect(@host.ssl_store.verify(@host.certificate.content)).to be_truthy
   end

data/spec/integration/ssl/key_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 
 require 'puppet/ssl/key'
 
-describe Puppet::SSL::Key do
+describe Puppet::SSL::Key, unless: Puppet::Util::Platform.jruby? do
   include PuppetSpec::Files
 
   # different UTF-8 widths
@@ -58,7 +58,7 @@ describe Puppet::SSL::Key do
 
       # indirector loads existing .pem off disk instead of replacing it
       host = Puppet::SSL::Host.new(key_name)
-      host.generate
+      host.key
 
       # newly loaded host private key matches the manually created key
       # Private-Key: (512 bit) style data
@@ -84,7 +84,7 @@ describe Puppet::SSL::Key do
       # note incorrect password is an error
       expect do
         Puppet::FileSystem.open(pem_path, nil, 'r:ASCII') do |f|
-          reloaded_key = OpenSSL::PKey::RSA.new(f.read, 'invalid_password')
+          OpenSSL::PKey::RSA.new(f.read, 'invalid_password')
         end
       end.to raise_error(OpenSSL::PKey::RSAError)