puppet 3.8.7 → 4.0.0.rc1

data/spec/integration/environments/setting_hooks_spec.rb

@@ -11,7 +11,7 @@ describe "setting hooks" do
       FileUtils.mkdir_p(productiondir)
     end
 
-    it "accesses correct directory environment settings after intializing a setting with an on_write hook" do
+    it "accesses correct directory environment settings after initializing a setting with an on_write hook" do
       expect(Puppet.settings.setting(:certname).call_hook).to eq(:on_write_only) 
 
       File.open(File.join(confdir, "puppet.conf"), "w") do |f|

data/spec/integration/environments/settings_interpolation_spec.rb

@@ -1,8 +1,11 @@
 require 'pp'
 require 'spec_helper'
+require 'puppet_spec/settings'
 
 module SettingsInterpolationSpec
 describe "interpolating $environment" do
+  include PuppetSpec::Settings
+
   let(:confdir) { Puppet[:confdir] }
   let(:cmdline_args) { ['--confdir', confdir, '--vardir', Puppet[:vardir], '--hiera_config', Puppet[:hiera_config]] }
 
@@ -32,134 +35,76 @@ describe "interpolating $environment" do
     end
   end
 
-  context "when environmentpath is set" do
-
-    describe "config_version" do
-      it "interpolates $environment" do
-        envname = 'testing'
-        setting = 'config_version'
-        value = '/some/script $environment'
-        expected = "#{File.expand_path('/some/script')} testing"
-
-        set_puppet_conf(confdir, <<-EOF)
-          environmentpath=$confdir/environments
-          environment=#{envname}
-        EOF
-
-        set_environment_conf("#{confdir}/environments", envname, <<-EOF)
-          #{setting}=#{value}
-        EOF
-
-        Puppet.initialize_settings(cmdline_args)
-        expect(Puppet[:environmentpath]).to eq("#{confdir}/environments")
-        environment = Puppet.lookup(:environments).get(envname)
-        expect(environment.config_version).to eq(expected)
-        expect(@logs).to be_empty
-      end
-    end
-
-    describe "basemodulepath" do
-      let(:setting) { "basemodulepath" }
-      let(:value) { "$confdir/environments/$environment/modules:$confdir/environments/$environment/other_modules" }
-      let(:expected) { "#{confdir}/environments/$environment/modules:#{confdir}/environments/$environment/other_modules" }
-
-      it_behaves_like "a setting that does not interpolate $environment"
-
-      it "logs a single warning for multiple instaces of $environment in the setting" do
-        set_puppet_conf(confdir, <<-EOF)
-          environmentpath=$confdir/environments
-          #{setting}=#{value}
-        EOF
+  describe "config_version" do
+    it "interpolates $environment" do
+      envname = 'testing'
+      setting = 'config_version'
+      value = '/some/script $environment'
+      expected = "#{File.expand_path('/some/script')} testing"
 
-        Puppet.initialize_settings(cmdline_args)
-        expect(@logs.map(&:to_s).grep(/cannot interpolate \$environment within '#{setting}'/).count).to eq(1)
-      end
-    end
+      set_puppet_conf(confdir, <<-EOF)
+        environmentpath=$confdir/environments
+        environment=#{envname}
+      EOF
 
-    describe "environment" do
-      let(:setting) { "environment" }
-      let(:value) { "whatareyouthinking$environment" }
-      let(:expected) { value }
+      set_environment_conf("#{confdir}/environments", envname, <<-EOF)
+        #{setting}=#{value}
+      EOF
 
-      it_behaves_like "a setting that does not interpolate $environment"
+      Puppet.initialize_settings(cmdline_args)
+      expect(Puppet[:environmentpath]).to eq("#{confdir}/environments")
+      environment = Puppet.lookup(:environments).get(envname)
+      expect(environment.config_version).to eq(expected)
+      expect(@logs).to be_empty
     end
+  end
 
-    describe "the default_manifest" do
-      let(:setting) { "default_manifest" }
-      let(:value) { "$confdir/manifests/$environment" }
-      let(:expected) { "#{confdir}/manifests/$environment" }
-
-      it_behaves_like "a setting that does not interpolate $environment"
-    end
+  describe "basemodulepath" do
+    let(:setting) { "basemodulepath" }
+    let(:value) { "$confdir/environments/$environment/modules:$confdir/environments/$environment/other_modules" }
+    let(:expected) { "#{confdir}/environments/$environment/modules:#{confdir}/environments/$environment/other_modules" }
 
-    it "does not interpolate $environment and logs a warning when interpolating environmentpath" do
-      setting = 'environmentpath'
-      value = "$confdir/environments/$environment"
-      expected = "#{confdir}/environments/$environment"
+    it_behaves_like "a setting that does not interpolate $environment"
 
+    it "logs a single warning for multiple instaces of $environment in the setting" do
       set_puppet_conf(confdir, <<-EOF)
+        environmentpath=$confdir/environments
         #{setting}=#{value}
       EOF
 
       Puppet.initialize_settings(cmdline_args)
-      expect(Puppet[setting.intern]).to eq(expected)
-      expect(@logs).to have_matching_log(/cannot interpolate \$environment within '#{setting}'/)
+      expect(@logs.map(&:to_s).grep(/cannot interpolate \$environment within '#{setting}'/).count).to eq(1)
     end
   end
 
-  def assert_does_interpolate_environment(setting, value, expected_interpolation)
-    set_puppet_conf(confdir, <<-EOF)
-      #{setting}=#{value}
-    EOF
+  describe "environment" do
+    let(:setting) { "environment" }
+    let(:value) { "whatareyouthinking$environment" }
+    let(:expected) { value }
 
-    Puppet.initialize_settings(cmdline_args)
-    expect(Puppet[:environmentpath]).to be_empty
-    expect(Puppet[setting.intern]).to eq(expected_interpolation)
-    expect(@logs).to_not have_matching_log(/cannot interpolate \$environment within '#{setting}'/)
+    it_behaves_like "a setting that does not interpolate $environment"
   end
 
-  context "when environmentpath is not set" do
-    it "does interpolate $environment in config_version" do
-      value = "/some/script $environment"
-      expect = "/some/script production"
-      assert_does_interpolate_environment("config_version", value, expect)
-    end
-
-    it "does interpolate $environment in basemodulepath" do
-      value = "$confdir/environments/$environment/modules:$confdir/environments/$environment/other_modules"
-      expected = "#{confdir}/environments/production/modules:#{confdir}/environments/production/other_modules"
-      assert_does_interpolate_environment("basemodulepath", value, expected)
-    end
-
-    it "does interpolate $environment in default_manifest, which is fine, because this setting isn't used" do
-      value = "$confdir/manifests/$environment"
-      expected = "#{confdir}/manifests/production"
-
-      assert_does_interpolate_environment("default_manifest", value, expected)
-    end
+  describe "the default_manifest" do
+    let(:setting) { "default_manifest" }
+    let(:value) { "$confdir/manifests/$environment" }
+    let(:expected) { "#{confdir}/manifests/$environment" }
 
-    it "raises something" do
-      value = expected = "whatareyouthinking$environment"
-      expect {
-        assert_does_interpolate_environment("environment", value, expected)
-      }.to raise_error(SystemStackError, /stack level too deep/)
-    end
+    it_behaves_like "a setting that does not interpolate $environment"
   end
 
-  def set_puppet_conf(confdir, settings)
-    write_file(File.join(confdir, "puppet.conf"), settings)
-  end
+  it "does not interpolate $environment and logs a warning when interpolating environmentpath" do
+    setting = 'environmentpath'
+    value = "$confdir/environments/$environment"
+    expected = "#{confdir}/environments/$environment"
 
-  def set_environment_conf(environmentpath, environment, settings)
-    envdir = File.join(environmentpath, environment)
-    FileUtils.mkdir_p(envdir)
-    write_file(File.join(envdir, 'environment.conf'), settings)
-  end
+    set_puppet_conf(confdir, <<-EOF)
+      #{setting}=#{value}
+    EOF
 
-  def write_file(file, contents)
-    File.open(file, "w") do |f|
-      f.puts(contents)
-    end
+    Puppet.initialize_settings(cmdline_args)
+    expect(Puppet[setting.intern]).to eq(expected)
+    expect(@logs).to have_matching_log(/cannot interpolate \$environment within '#{setting}'/)
   end
 end
 end

data/spec/integration/environments/settings_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+require 'puppet_spec/settings'
+
+describe "environment settings" do
+  include PuppetSpec::Settings
+
+  let(:confdir) { Puppet[:confdir] }
+  let(:cmdline_args) { ['--confdir', confdir, '--vardir', Puppet[:vardir], '--hiera_config', Puppet[:hiera_config]] }
+  let(:environmentpath) { File.expand_path("envdir", confdir) }
+  let(:testingdir) { File.join(environmentpath, "testing") }
+
+  before(:each) do
+    FileUtils.mkdir_p(testingdir)
+  end
+
+  def init_puppet_conf(settings = {})
+    set_puppet_conf(confdir, <<-EOF)
+      environmentpath=#{environmentpath}
+      #{settings.map { |k,v| "#{k}=#{v}" }.join("\n")}
+    EOF
+    Puppet.initialize_settings
+  end
+
+  it "raises an error if you set manifest in puppet.conf" do
+    expect { init_puppet_conf("manifest" => "/something") }.to raise_error(Puppet::Settings::SettingsError, /Cannot set manifest.*in puppet.conf/)
+  end
+
+  it "raises an error if you set modulepath in puppet.conf" do
+    expect { init_puppet_conf("modulepath" => "/something") }.to raise_error(Puppet::Settings::SettingsError, /Cannot set modulepath.*in puppet.conf/)
+  end
+
+  it "raises an error if you set config_version in puppet.conf" do
+    expect { init_puppet_conf("config_version" => "/something") }.to raise_error(Puppet::Settings::SettingsError, /Cannot set config_version.*in puppet.conf/)
+  end
+
+  context "when given an environment" do
+    before(:each) do
+      init_puppet_conf
+    end
+
+    context "without an environment.conf" do
+      it "reads manifest from environment.conf defaults" do
+        expect(Puppet.settings.value(:manifest, :testing)).to eq(File.join(testingdir, "manifests"))
+      end
+
+      it "reads modulepath from environment.conf defaults" do
+        expect(Puppet.settings.value(:modulepath, :testing)).to match(/#{File.join(testingdir, "modules")}/)
+      end
+
+      it "reads config_version from environment.conf defaults" do
+        expect(Puppet.settings.value(:config_version, :testing)).to eq('')
+      end
+    end
+
+    context "with an environment.conf" do
+      before(:each) do
+        set_environment_conf(environmentpath, 'testing', <<-EOF)
+          manifest=/special/manifest
+          modulepath=/special/modulepath
+          config_version=/special/config_version
+        EOF
+      end
+
+      it "reads the configured manifest" do
+        expect(Puppet.settings.value(:manifest, :testing)).to eq(File.expand_path('/special/manifest'))
+      end
+
+      it "reads the configured modulepath" do
+        expect(Puppet.settings.value(:modulepath, :testing)).to eq(File.expand_path('/special/modulepath'))
+      end
+
+      it "reads the configured config_version" do
+        expect(Puppet.settings.value(:config_version, :testing)).to eq(File.expand_path('/special/config_version'))
+      end
+    end
+
+    context "when environment name collides with a puppet.conf section" do
+      let(:testingdir) { File.join(environmentpath, "main") }
+
+      it "reads manifest from environment.conf defaults" do
+        expect(Puppet.settings.value(:environmentpath)).to eq(environmentpath)
+        expect(Puppet.settings.value(:manifest, :main)).to eq(File.join(testingdir, "manifests"))
+      end
+
+      context "and an environment.conf" do
+        before(:each) do
+          set_environment_conf(environmentpath, 'main', <<-EOF)
+            manifest=/special/manifest
+          EOF
+        end
+
+        it "reads manifest from environment.conf settings" do
+          expect(Puppet.settings.value(:environmentpath)).to eq(environmentpath)
+          expect(Puppet.settings.value(:manifest, :main)).to eq(File.expand_path("/special/manifest"))
+        end
+      end
+    end
+  end
+
+end

data/spec/integration/faces/ca_spec.rb

@@ -35,27 +35,27 @@ describe Puppet::Face[:ca, '0.1.0'], :unless => Puppet.features.microsoft_window
 
   context "#verify" do
     it "should report if there is no certificate" do
-      subject.verify('random-host').should == {
+      expect(subject.verify('random-host')).to eq({
         :host => 'random-host', :valid => false,
         :error => 'Could not find a certificate for random-host'
-      }
+      })
     end
 
     it "should report that it cannot find a certificate when there is only a request" do
       given_certificate_requests_for('random-host')
 
-      subject.verify('random-host').should == {
+      expect(subject.verify('random-host')).to eq({
         :host => 'random-host', :valid => false,
         :error => 'Could not find a certificate for random-host'
-      }
+      })
     end
 
     it "should verify a signed certificate" do
       given_certificates_for('random-host')
 
-      subject.verify('random-host').should == {
+      expect(subject.verify('random-host')).to eq({
         :host => 'random-host', :valid => true
-      }
+      })
     end
 
     it "should not verify a revoked certificate" do
@@ -63,10 +63,10 @@ describe Puppet::Face[:ca, '0.1.0'], :unless => Puppet.features.microsoft_window
 
       subject.revoke('random-host')
 
-      subject.verify('random-host').should == {
+      expect(subject.verify('random-host')).to eq({
         :host => 'random-host', :valid => false,
         :error => 'certificate revoked'
-      }
+      })
     end
 
     it "should verify a revoked certificate if CRL use was turned off" do
@@ -75,9 +75,9 @@ describe Puppet::Face[:ca, '0.1.0'], :unless => Puppet.features.microsoft_window
 
       Puppet[:certificate_revocation] = false
 
-      subject.verify('random-host').should == {
+      expect(subject.verify('random-host')).to eq({
         :host => 'random-host', :valid => true
-      }
+      })
     end
   end
 
@@ -85,39 +85,39 @@ describe Puppet::Face[:ca, '0.1.0'], :unless => Puppet.features.microsoft_window
     let(:fingerprint_re) { /^\([0-9A-Z]+\) [0-9A-F:]+$/ }
 
     it "should be nil if there is no certificate" do
-      subject.fingerprint('random-host').should be_nil
+      expect(subject.fingerprint('random-host')).to be_nil
     end
 
     it "should fingerprint a CSR" do
       given_certificate_requests_for('random-host')
 
-      subject.fingerprint('random-host').should =~ fingerprint_re
+      expect(subject.fingerprint('random-host')).to match(fingerprint_re)
     end
 
     it "should fingerprint a certificate" do
       given_certificates_for('random-host')
 
-      subject.fingerprint('random-host').should =~ fingerprint_re
+      expect(subject.fingerprint('random-host')).to match(fingerprint_re)
     end
 
     %w{md5 MD5 sha1 SHA1 RIPEMD160 sha256 sha512}.each do |digest|
       it "should fingerprint with #{digest.inspect}" do
         given_certificates_for('random-host')
 
-        subject.fingerprint('random-host', :digest => digest).should =~ fingerprint_re
+        expect(subject.fingerprint('random-host', :digest => digest)).to match(fingerprint_re)
       end
     end
   end
 
   context "#print" do
     it "should be nil if there is no certificate" do
-      subject.print('random-host').should be_nil
+      expect(subject.print('random-host')).to be_nil
     end
 
     it "should return nothing if there is only a CSR" do
       given_certificate_requests_for('random-host')
 
-      subject.print('random-host').should be_nil
+      expect(subject.print('random-host')).to be_nil
     end
 
     it "should return the certificate content if there is a cert" do
@@ -125,32 +125,32 @@ describe Puppet::Face[:ca, '0.1.0'], :unless => Puppet.features.microsoft_window
 
       text = subject.print('random-host')
 
-      text.should be_an_instance_of String
-      text.should =~ /^Certificate:/
-      text.should =~ /Issuer: CN=Puppet CA: /
-      text.should =~ /Subject: CN=random-host$/
+      expect(text).to be_an_instance_of String
+      expect(text).to match(/^Certificate:/)
+      expect(text).to match(/Issuer: CN=Puppet CA: /)
+      expect(text).to match(/Subject: CN=random-host$/)
     end
   end
 
   context "#sign" do
     it "should report that there is no CSR" do
-      subject.sign('random-host').should == 'Could not find certificate request for random-host'
+      expect(subject.sign('random-host')).to eq('Could not find certificate request for random-host')
     end
 
     it "should report that there is no CSR when even when there is a certificate" do
       given_certificates_for('random-host')
 
-      subject.sign('random-host').should == 'Could not find certificate request for random-host'
+      expect(subject.sign('random-host')).to eq('Could not find certificate request for random-host')
     end
 
     it "should sign a CSR if one exists" do
       given_certificate_requests_for('random-host')
 
-      subject.sign('random-host').should be_an_instance_of Puppet::SSL::Certificate
+      expect(subject.sign('random-host')).to be_an_instance_of Puppet::SSL::Certificate
 
       list = subject.list(:signed => true)
-      list.length.should == 1
-      list.first.name.should == 'random-host'
+      expect(list.length).to eq(1)
+      expect(list.first.name).to eq('random-host')
     end
 
     describe "when the CSR specifies DNS alt names" do
@@ -163,7 +163,7 @@ describe Puppet::Face[:ca, '0.1.0'], :unless => Puppet.features.microsoft_window
       it "should sign the CSR if DNS alt names are allowed" do
         subject.sign('someone', :allow_dns_alt_names => true)
 
-        host.certificate.should be_a(Puppet::SSL::Certificate)
+        expect(host.certificate).to be_a(Puppet::SSL::Certificate)
       end
 
       it "should refuse to sign the CSR if DNS alt names are not allowed" do
@@ -172,32 +172,32 @@ describe Puppet::Face[:ca, '0.1.0'], :unless => Puppet.features.microsoft_window
           subject.sign(certname)
         end.to raise_error(Puppet::SSL::CertificateAuthority::CertificateSigningError, /CSR '#{certname}' contains subject alternative names \(.*\), which are disallowed. Use `puppet cert --allow-dns-alt-names sign #{certname}` to sign this request./i)
 
-        host.certificate.should be_nil
+        expect(host.certificate).to be_nil
       end
     end
   end
 
   context "#generate" do
     it "should generate a certificate if requested" do
-      subject.list(:all => true).should == []
+      expect(subject.list(:all => true)).to eq([])
 
       subject.generate('random-host')
 
       list = subject.list(:signed => true)
-      list.length.should == 1
-      list.first.name.should == 'random-host'
+      expect(list.length).to eq(1)
+      expect(list.first.name).to eq('random-host')
     end
 
     it "should report if a CSR with that name already exists" do
       given_certificate_requests_for('random-host')
 
-      subject.generate('random-host').should =~ /already has a certificate request/
+      expect(subject.generate('random-host')).to match(/already has a certificate request/)
     end
 
     it "should report if the certificate with that name already exists" do
       given_certificates_for('random-host')
 
-      subject.generate('random-host').should =~ /already has a certificate/
+      expect(subject.generate('random-host')).to match(/already has a certificate/)
     end
 
     it "should include the specified DNS alt names" do
@@ -205,16 +205,16 @@ describe Puppet::Face[:ca, '0.1.0'], :unless => Puppet.features.microsoft_window
 
       host = subject.list(:signed => true).first
 
-      host.name.should == 'some-host'
-      host.certificate.subject_alt_names.should =~ %w[DNS:some DNS:alt DNS:names DNS:some-host]
+      expect(host.name).to eq('some-host')
+      expect(host.certificate.subject_alt_names).to match_array(%w[DNS:some DNS:alt DNS:names DNS:some-host])
 
-      subject.list(:pending => true).should be_empty
+      expect(subject.list(:pending => true)).to be_empty
     end
   end
 
   context "#revoke" do
     it "should let the user know what went wrong when there is nothing to revoke" do
-      subject.revoke('nonesuch').should == 'Nothing was revoked'
+      expect(subject.revoke('nonesuch')).to eq('Nothing was revoked')
     end
 
     it "should revoke a certificate" do
@@ -223,14 +223,14 @@ describe Puppet::Face[:ca, '0.1.0'], :unless => Puppet.features.microsoft_window
       subject.revoke('random-host')
 
       found = subject.list(:all => true, :subject => 'random-host')
-      subject.get_action(:list).when_rendering(:console).call(found, {}).
-        should =~ /^- random-host  \(\w+\) [:0-9A-F]+ \(certificate revoked\)/
+      expect(subject.get_action(:list).when_rendering(:console).call(found, {})).
+        to match(/^- random-host  \(\w+\) [:0-9A-F]+ \(certificate revoked\)/)
     end
   end
 
   context "#destroy" do
     it "should let the user know if nothing was deleted" do
-      subject.destroy('nonesuch').should == "Nothing was deleted"
+      expect(subject.destroy('nonesuch')).to eq("Nothing was deleted")
     end
 
     it "should destroy a CSR, if we have one" do
@@ -238,7 +238,7 @@ describe Puppet::Face[:ca, '0.1.0'], :unless => Puppet.features.microsoft_window
 
       subject.destroy('random-host')
 
-      subject.list(:pending => true, :subject => 'random-host').should == []
+      expect(subject.list(:pending => true, :subject => 'random-host')).to eq([])
     end
 
     it "should destroy a certificate, if we have one" do
@@ -246,16 +246,16 @@ describe Puppet::Face[:ca, '0.1.0'], :unless => Puppet.features.microsoft_window
 
       subject.destroy('random-host')
 
-      subject.list(:signed => true, :subject => 'random-host').should == []
+      expect(subject.list(:signed => true, :subject => 'random-host')).to eq([])
     end
 
     it "should tell the user something was deleted" do
       given_certificates_for('random-host')
 
-      subject.list(:signed => true, :subject => 'random-host').should_not == []
+      expect(subject.list(:signed => true, :subject => 'random-host')).not_to eq([])
 
-      subject.destroy('random-host').
-        should == "Deleted for random-host: Puppet::SSL::Certificate"
+      expect(subject.destroy('random-host')).
+        to eq("Deleted for random-host: Puppet::SSL::Certificate")
     end
   end
 
@@ -268,16 +268,16 @@ describe Puppet::Face[:ca, '0.1.0'], :unless => Puppet.features.microsoft_window
         { :all => true },
       ].each do |type|
         it "should return nothing for #{type.inspect}" do
-          subject.list(type).should == []
+          expect(subject.list(type)).to eq([])
         end
 
         it "should return nothing when a matcher is passed" do
-          subject.list(type.merge :subject => '.').should == []
+          expect(subject.list(type.merge :subject => '.')).to eq([])
         end
 
         context "when_rendering :console" do
           it "should return nothing for #{type.inspect}" do
-            subject.get_action(:list).when_rendering(:console).call(subject.list(type), {}).should == ""
+            expect(subject.get_action(:list).when_rendering(:console).call(subject.list(type), {})).to eq("")
           end
         end
       end
@@ -301,7 +301,7 @@ describe Puppet::Face[:ca, '0.1.0'], :unless => Puppet.features.microsoft_window
           given_certificate_requests_for(*csr_names)
           given_certificates_for(*crt_names)
 
-          subject.list(input).map(&:name).should =~ expect
+          expect(subject.list(input).map(&:name)).to match_array(expect)
         end
 
         ['', '.', '2', 'none'].each do |pattern|
@@ -311,7 +311,7 @@ describe Puppet::Face[:ca, '0.1.0'], :unless => Puppet.features.microsoft_window
             given_certificate_requests_for(*csr_names)
             given_certificates_for(*crt_names)
 
-            subject.list(input.merge :subject => pattern).map(&:name).should =~ filtered
+            expect(subject.list(input.merge :subject => pattern).map(&:name)).to match_array(filtered)
           end
         end
       end
@@ -328,7 +328,7 @@ describe Puppet::Face[:ca, '0.1.0'], :unless => Puppet.features.microsoft_window
             text = subject.get_action(:list).when_rendering(:console).call(subject.list(:all => true), {})
 
             pattern.each do |item|
-              text.should =~ item
+              expect(text).to match(item)
             end
           end
         end
@@ -338,7 +338,7 @@ describe Puppet::Face[:ca, '0.1.0'], :unless => Puppet.features.microsoft_window
 
   actions = %w{destroy list revoke generate sign print verify fingerprint}
   actions.each do |action|
-    it { should be_action action }
+    it { is_expected.to be_action action }
     it "should fail #{action} when not a CA" do
       Puppet[:ca] = false
       expect {