puppet 3.4.3 → 3.5.0.rc1

data/spec/unit/application/device_spec.rb

@@ -127,7 +127,6 @@ describe Puppet::Application::Device do
     before :each do
       @device.options.stubs(:[])
       Puppet.stubs(:info)
-      Puppet::FileSystem::File.stubs(:exist?).returns(true)
       Puppet[:libdir] = "/dev/null/lib"
       Puppet::SSL::Host.stubs(:ca_location=)
       Puppet::Transaction::Report.indirection.stubs(:terminus_class=)
@@ -301,7 +300,7 @@ describe Puppet::Application::Device do
           "device2" => OpenStruct.new(:name => "device2", :url => "url", :provider => "cisco"),
         }
         Puppet::Util::NetworkDevice::Config.stubs(:devices).returns(@device_hash)
-        Puppet.settings.stubs(:set_value)
+        Puppet.stubs(:[]=)
         Puppet.settings.stubs(:use)
         @device.stubs(:setup_host)
         Puppet::Util::NetworkDevice.stubs(:init)
@@ -310,18 +309,18 @@ describe Puppet::Application::Device do
       end
 
       it "should set vardir to the device vardir" do
-        Puppet.settings.expects(:set_value).with(:vardir, make_absolute("/dummy/devices/device1"), :cli)
+        Puppet.expects(:[]=).with(:vardir, make_absolute("/dummy/devices/device1"))
         @device.main
       end
 
       it "should set confdir to the device confdir" do
-        Puppet.settings.expects(:set_value).with(:confdir, make_absolute("/dummy/devices/device1"), :cli)
+        Puppet.expects(:[]=).with(:confdir, make_absolute("/dummy/devices/device1"))
         @device.main
       end
 
       it "should set certname to the device certname" do
-        Puppet.settings.expects(:set_value).with(:certname, "device1", :cli)
-        Puppet.settings.expects(:set_value).with(:certname, "device2", :cli)
+        Puppet.expects(:[]=).with(:certname, "device1")
+        Puppet.expects(:[]=).with(:certname, "device2")
         @device.main
       end
 
@@ -350,31 +349,29 @@ describe Puppet::Application::Device do
           all_devices = Set.new(@device_hash.keys.map do |device_name| make_absolute("/dummy/devices/#{device_name}") end)
           found_devices = Set.new()
 
-          # a block to use in a few places later to validate the arguments passed to "set_value"
-          p = Proc.new do |my_setting, my_value, my_type|
-            success =
-                  (my_setting == setting) &&
-                    (my_type == :cli) &&
-                    (all_devices.include?(my_value))
-                found_devices.add(my_value) if success
-                success
+          # a block to use in a few places later to validate the updated settings
+          p = Proc.new do |my_setting, my_value|
+            if my_setting == setting && all_devices.include?(my_value)
+              found_devices.add(my_value)
+              true
+            else
+              false
+            end
           end
 
           seq = sequence("clean up dirs")
 
           all_devices.size.times do
             ## one occurrence of set / run / set("/dummy") for each device
-            Puppet.settings.expects(:set_value).with(&p).in_sequence(seq)
+            Puppet.expects(:[]=).with(&p).in_sequence(seq)
             @configurer.expects(:run).in_sequence(seq)
-            Puppet.settings.expects(:set_value).with(setting, make_absolute("/dummy"), :cli).in_sequence(seq)
+            Puppet.expects(:[]=).with(setting, make_absolute("/dummy")).in_sequence(seq)
           end
 
 
           @device.main
 
-          # make sure that we were called with each of the defined devices
-          all_devices.should == found_devices
-
+          expect(found_devices).to eq(all_devices)
         end
       end
 
@@ -382,32 +379,30 @@ describe Puppet::Application::Device do
         all_devices = Set.new(@device_hash.keys)
         found_devices = Set.new()
 
-        # a block to use in a few places later to validate the arguments passed to "set_value"
-        p = Proc.new do |my_setting, my_value, my_type|
-          success =
-              (my_setting == :certname) &&
-                  (my_type == :cli) &&
-                  (all_devices.include?(my_value))
-          found_devices.add(my_value) if success
-          success
-          #true
+        # a block to use in a few places later to validate the updated settings
+        p = Proc.new do |my_setting, my_value|
+          if my_setting == :certname && all_devices.include?(my_value)
+            found_devices.add(my_value)
+            true
+          else
+            false
+          end
         end
 
         seq = sequence("clean up certname")
 
         all_devices.size.times do
           ## one occurrence of set / run / set("certname") for each device
-          Puppet.settings.expects(:set_value).with(&p).in_sequence(seq)
+          Puppet.expects(:[]=).with(&p).in_sequence(seq)
           @configurer.expects(:run).in_sequence(seq)
-          Puppet.settings.expects(:set_value).with(:certname, "certname", :cli).in_sequence(seq)
+          Puppet.expects(:[]=).with(:certname, "certname").in_sequence(seq)
         end
 
 
         @device.main
 
         # make sure that we were called with each of the defined devices
-        all_devices.should == found_devices
-
+        expect(found_devices).to eq(all_devices)
       end
 
       it "should expire all cached attributes" do

data/spec/unit/application/doc_spec.rb

@@ -223,18 +223,18 @@ describe Puppet::Application::Doc do
           @doc.unknown_args = [ { :opt => "--modulepath", :arg => "path" } ]
           Puppet.settings.stubs(:handlearg)
 
-          File.expects(:expand_path).with("path")
-
           @doc.setup_rdoc
+
+          @doc.unknown_args[0][:arg].should == File.expand_path('path')
         end
 
         it "should expand --manifestdir if any" do
           @doc.unknown_args = [ { :opt => "--manifestdir", :arg => "path" } ]
           Puppet.settings.stubs(:handlearg)
 
-          File.expects(:expand_path).with("path")
-
           @doc.setup_rdoc
+
+          @doc.unknown_args[0][:arg].should == File.expand_path('path')
         end
 
         it "should give them to Puppet.settings" do

data/spec/unit/application/filebucket_spec.rb

@@ -178,7 +178,7 @@ describe Puppet::Application::Filebucket do
 
       it "should call the client backup method for each given parameter" do
         @filebucket.stubs(:puts)
-        Puppet::FileSystem::File.stubs(:exist?).returns(true)
+        Puppet::FileSystem.stubs(:exist?).returns(true)
         FileTest.stubs(:readable?).returns(true)
         @filebucket.stubs(:args).returns(["file1", "file2"])
 

data/spec/unit/application/master_spec.rb

@@ -252,14 +252,14 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
       it "should exit with error code 30 if no catalog can be found" do
         @master.options[:node] = "foo"
         Puppet::Resource::Catalog.indirection.expects(:find).returns nil
-        $stderr.expects(:puts)
+        Puppet.expects(:log_exception)
         expect { @master.compile }.to exit_with 30
       end
 
       it "should exit with error code 30 if there's a failure" do
         @master.options[:node] = "foo"
         Puppet::Resource::Catalog.indirection.expects(:find).raises ArgumentError
-        $stderr.expects(:puts)
+        Puppet.expects(:log_exception)
         expect { @master.compile }.to exit_with 30
       end
     end

data/spec/unit/application_spec.rb

@@ -604,7 +604,7 @@ describe Puppet::Application do
           @app.parse_options
         end
 
-        it "should give to OptionParser a block that adds the the value to the options array" do
+        it "should give to OptionParser a block that adds the value to the options array" do
           OptionParser.any_instance.stubs(:on)
           OptionParser.any_instance.stubs(:on).with("--test4","-t").yields(nil)
 

data/spec/unit/configurer/downloader_spec.rb

@@ -136,7 +136,7 @@ describe Puppet::Configurer::Downloader do
       Puppet[:tags] = 'maytag'
       @dler.evaluate
 
-      Puppet::FileSystem::File.exist?(@dl_name).should be_true
+      Puppet::FileSystem.exist?(@dl_name).should be_true
     end
 
     it "should log that it is downloading" do

data/spec/unit/configurer/fact_handler_spec.rb

@@ -2,16 +2,7 @@
 require 'spec_helper'
 require 'puppet/configurer'
 require 'puppet/configurer/fact_handler'
-
-# the json-schema gem doesn't support windows
-if not Puppet.features.microsoft_windows?
-  describe "catalog facts schema" do
-    it "should validate against the json meta-schema" do
-      JSON::Validator.validate!(JSON_META_SCHEMA, FACTS_SCHEMA)
-    end
-  end
-
- end
+require 'matchers/json'
 
 class FactHandlerTester
   include Puppet::Configurer::FactHandler
@@ -22,6 +13,8 @@ class FactHandlerTester
 end
 
 describe Puppet::Configurer::FactHandler do
+  include JSONMatchers
+
   before :each do
     @facthandler = FactHandlerTester.new
     Puppet::Node::Facts.indirection.terminus_class = :memory
@@ -85,15 +78,11 @@ describe Puppet::Configurer::FactHandler do
     @facthandler.facts_for_uploading.should == {:facts_format => :pson, :facts => text}
   end
 
-  def validate_json_for_facts(catalog_facts)
-    JSON::Validator.validate!(FACTS_SCHEMA, catalog_facts)
-  end
-
-  it "should generate valid facts data against the facts schema", :unless => Puppet.features.microsoft_windows? do
+  it "should generate valid facts data against the facts schema" do
     facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
     Puppet::Node::Facts.indirection.save(facts)
 
-    validate_json_for_facts(CGI.unescape(@facthandler.facts_for_uploading[:facts]))
+    expect(CGI.unescape(@facthandler.facts_for_uploading[:facts])).to validate_against('api/schemas/facts.json')
   end
 
 end

data/spec/unit/configurer_spec.rb

@@ -464,7 +464,7 @@ describe Puppet::Configurer do
 
     it "should write the last run file" do
       @configurer.save_last_run_summary(@report)
-      Puppet::FileSystem::File.exist?(Puppet[:lastrunfile]).should be_true
+      Puppet::FileSystem.exist?(Puppet[:lastrunfile]).should be_true
     end
 
     it "should write the raw summary as yaml" do
@@ -496,7 +496,7 @@ describe Puppet::Configurer do
         require 'puppet/util/windows/security'
         mode = Puppet::Util::Windows::Security.get_mode(Puppet[:lastrunfile])
       else
-        mode = Puppet::FileSystem::File.new(Puppet[:lastrunfile]).stat.mode
+        mode = Puppet::FileSystem.stat(Puppet[:lastrunfile]).mode
       end
       (mode & 0777).should == 0664
     end

data/spec/unit/confine/exists_spec.rb

@@ -30,12 +30,12 @@ describe Puppet::Confine::Exists do
   end
 
   it "should return false if the value does not point to a file" do
-    Puppet::FileSystem::File.expects(:exist?).with("/my/file").returns false
+    Puppet::FileSystem.expects(:exist?).with("/my/file").returns false
     @confine.pass?("/my/file").should be_false
   end
 
   it "should return true if the value points to a file" do
-    Puppet::FileSystem::File.expects(:exist?).with("/my/file").returns true
+    Puppet::FileSystem.expects(:exist?).with("/my/file").returns true
     @confine.pass?("/my/file").should be_true
   end
 
@@ -62,9 +62,9 @@ describe Puppet::Confine::Exists do
   end
 
   it "should produce a summary containing all missing files" do
-    Puppet::FileSystem::File.stubs(:exist?).returns true
-    Puppet::FileSystem::File.expects(:exist?).with("/two").returns false
-    Puppet::FileSystem::File.expects(:exist?).with("/four").returns false
+    Puppet::FileSystem.stubs(:exist?).returns true
+    Puppet::FileSystem.expects(:exist?).with("/two").returns false
+    Puppet::FileSystem.expects(:exist?).with("/four").returns false
 
     confine = Puppet::Confine::Exists.new %w{/one /two /three /four}
     confine.summary.should == %w{/two /four}

data/spec/unit/context/trusted_information_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe Puppet::Context::TrustedInformation do
+  let(:key) do
+    key = Puppet::SSL::Key.new("myname")
+    key.generate
+    key
+  end
+
+  let(:csr) do
+    csr = Puppet::SSL::CertificateRequest.new("csr")
+    csr.generate(key, :extension_requests => {
+      '1.3.6.1.4.1.15.1.2.1' => 'Ignored CSR extension',
+
+      '1.3.6.1.4.1.34380.1.2.1' => 'CSR specific info',
+      '1.3.6.1.4.1.34380.1.2.2' => 'more CSR specific info',
+    })
+    csr
+  end
+
+  let(:cert) do
+    Puppet::SSL::Certificate.from_instance(Puppet::SSL::CertificateFactory.build('ca', csr, csr.content, 1))
+  end
+
+  context "when remote" do
+    it "has no cert information when it isn't authenticated" do
+      trusted = Puppet::Context::TrustedInformation.remote(false, 'ignored', nil)
+
+      expect(trusted.authenticated).to eq(false)
+      expect(trusted.certname).to be_nil
+      expect(trusted.extensions).to eq({})
+    end
+
+    it "is remote and has certificate information when it is authenticated" do
+      trusted = Puppet::Context::TrustedInformation.remote(true, 'cert name', cert)
+
+      expect(trusted.authenticated).to eq('remote')
+      expect(trusted.certname).to eq('cert name')
+      expect(trusted.extensions).to eq({
+        '1.3.6.1.4.1.34380.1.2.1' => 'CSR specific info',
+        '1.3.6.1.4.1.34380.1.2.2' => 'more CSR specific info',
+      })
+    end
+
+    it "is remote but lacks certificate information when it is authenticated" do
+      Puppet.expects(:info).once.with("TrustedInformation expected a certificate, but none was given.")
+
+      trusted = Puppet::Context::TrustedInformation.remote(true, 'cert name', nil)
+
+      expect(trusted.authenticated).to eq('remote')
+      expect(trusted.certname).to eq('cert name')
+      expect(trusted.extensions).to eq({})
+    end
+  end
+
+  context "when local" do
+    it "is authenticated local with the nodes clientcert" do
+      node = Puppet::Node.new('testing', :parameters => { 'clientcert' => 'cert name' })
+
+      trusted = Puppet::Context::TrustedInformation.local(node)
+
+      expect(trusted.authenticated).to eq('local')
+      expect(trusted.certname).to eq('cert name')
+      expect(trusted.extensions).to eq({})
+    end
+
+    it "is authenticated local with no clientcert when there is no node" do
+      trusted = Puppet::Context::TrustedInformation.local(nil)
+
+      expect(trusted.authenticated).to eq('local')
+      expect(trusted.certname).to be_nil
+      expect(trusted.extensions).to eq({})
+    end
+  end
+
+  it "converts itself to a hash" do
+    trusted = Puppet::Context::TrustedInformation.remote(true, 'cert name', cert)
+
+    expect(trusted.to_h).to eq({
+      'authenticated' => 'remote',
+      'certname' => 'cert name',
+      'extensions' => {
+        '1.3.6.1.4.1.34380.1.2.1' => 'CSR specific info',
+        '1.3.6.1.4.1.34380.1.2.2' => 'more CSR specific info',
+      }
+    })
+  end
+
+  it "freezes the hash" do
+    trusted = Puppet::Context::TrustedInformation.remote(true, 'cert name', cert)
+
+    expect(trusted.to_h).to be_deeply_frozen
+  end
+
+  matcher :be_deeply_frozen do
+    match do |actual|
+      unfrozen_items(actual).empty?
+    end
+
+    failure_message_for_should do |actual|
+      "expected all items to be frozen but <#{unfrozen_items(actual).join(', ')}> was not"
+    end
+
+    define_method :unfrozen_items do |actual|
+      unfrozen = []
+      stack = [actual]
+      while item = stack.pop
+        if !item.frozen?
+          unfrozen.push(item)
+        end
+
+        case item
+        when Hash
+          stack.concat(item.keys)
+          stack.concat(item.values)
+        when Array
+          stack.concat(item)
+        end
+      end
+
+      unfrozen
+    end
+  end
+end

data/spec/unit/context_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe Puppet::Context do
+  let(:context) { Puppet::Context.new({ :testing => "value" }) }
+
+  context "with the implicit test_helper.rb pushed context" do
+    it "fails to lookup a value that does not exist" do
+      expect { context.lookup("a") }.to raise_error(Puppet::Context::UndefinedBindingError)
+    end
+
+    it "calls a provided block for a default value when none is found" do
+      expect(context.lookup("a") { "default" }).to eq("default")
+    end
+
+    it "behaves as if pushed a {} if you push nil" do
+      context.push(nil)
+      expect(context.lookup(:testing)).to eq("value")
+      context.pop
+    end
+
+    it "fails if you try to pop off the top of the stack" do
+      expect { context.pop }.to raise_error(Puppet::Context::StackUnderflow)
+    end
+  end
+
+  describe "with additional context" do
+    before :each do
+      context.push("a" => 1)
+    end
+
+    it "holds values for later lookup" do
+      expect(context.lookup("a")).to eq(1)
+    end
+
+    it "allows rebinding values in a nested context" do
+      inner = nil
+      context.override("a" => 2) do
+        inner = context.lookup("a")
+      end
+
+      expect(inner).to eq(2)
+    end
+
+    it "outer bindings are available in an overridden context" do
+      inner_a = nil
+      inner_b = nil
+      context.override("b" => 2) do
+        inner_a = context.lookup("a")
+        inner_b = context.lookup("b")
+      end
+
+      expect(inner_a).to eq(1)
+      expect(inner_b).to eq(2)
+    end
+
+    it "overridden bindings do not exist outside of the override" do
+      context.override("a" => 2) do
+      end
+
+      expect(context.lookup("a")).to eq(1)
+    end
+
+    it "overridden bindings do not exist outside of the override even when leaving via an error" do
+      begin
+        context.override("a" => 2) do
+          raise "this should still cause the bindings to leave"
+        end
+      rescue
+      end
+
+      expect(context.lookup("a")).to eq(1)
+    end
+  end
+end