puppet 4.10.12-universal-darwin → 5.0.0-universal-darwin

data/spec/unit/application/config_spec.rb

@@ -6,8 +6,4 @@ describe Puppet::Application::Config do
   it "should be a subclass of Puppet::Application::FaceBase" do
     expect(Puppet::Application::Config.superclass).to equal(Puppet::Application::FaceBase)
   end
-
-  it "should set `environment_mode` to :not_required" do
-    expect(Puppet::Application::Config.get_environment_mode).to equal(:not_required)
-  end
 end

data/spec/unit/application/describe_spec.rb

@@ -76,4 +76,23 @@ describe Puppet::Application::Describe do
       @describe.run_command
     end
   end
+
+  it "should format text with long non-space runs without garbling" do
+    @f = Formatter.new(76)
+
+    @teststring = <<TESTSTRING
+. 12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890 nick@magpie.puppetlabs.lan
+**this part should not repeat!**
+TESTSTRING
+
+    @expected_result = <<EXPECTED
+.
+1234567890123456789012345678901234567890123456789012345678901234567890123456
+7890123456789012345678901234567890 nick@magpie.puppetlabs.lan
+**this part should not repeat!**
+EXPECTED
+
+    result = @f.wrap(@teststring, {:indent => 0, :scrub => true})
+    expect(result).to eql(@expected_result)
+  end
 end

data/spec/unit/application/device_spec.rb

@@ -47,6 +47,12 @@ describe Puppet::Application::Device do
 
       expect(@device.options[:waitforcert]).to be_nil
     end
+
+    it "should init target to nil" do
+      @device.preinit
+
+      expect(@device.options[:target]).to be_nil
+    end
   end
 
   describe "when handling options" do
@@ -265,12 +271,12 @@ describe Puppet::Application::Device do
     end
   end
 
-
   describe "when running" do
     before :each do
       @device.options.stubs(:[]).with(:fingerprint).returns(false)
       Puppet.stubs(:notice)
       @device.options.stubs(:[]).with(:detailed_exitcodes).returns(false)
+      @device.options.stubs(:[]).with(:target).returns(nil)
       @device.options.stubs(:[]).with(:client)
       Puppet::Util::NetworkDevice::Config.stubs(:devices).returns({})
     end
@@ -286,6 +292,32 @@ describe Puppet::Application::Device do
       expect { @device.main }.to exit_with 1
     end
 
+    it "should get a single device, when a valid target parameter is passed" do
+      @device.options.stubs(:[]).with(:target).returns('device1')
+
+      device_hash = {
+        "device1" => OpenStruct.new(:name => "device1", :url => "ssh://user:pass@testhost", :provider => "cisco"),
+        "device2" => OpenStruct.new(:name => "device2", :url => "https://user:pass@testhost/some/path", :provider => "rest"),
+      }
+
+      Puppet::Util::NetworkDevice::Config.expects(:devices).returns(device_hash)
+      Puppet.expects(:info).with("starting applying configuration to device1 at ssh://testhost")
+      Puppet.expects(:info).with("starting applying configuration to device2 at https://testhost:443/some/path").never
+      expect { @device.main }.to exit_with 1
+    end
+
+    it "should exit, when an invalid target parameter is passed" do
+      @device.options.stubs(:[]).with(:target).returns('bla')
+      device_hash = {
+        "device1" => OpenStruct.new(:name => "device1", :url => "ssh://user:pass@testhost", :provider => "cisco"),
+      }
+
+      Puppet::Util::NetworkDevice::Config.expects(:devices).returns(device_hash)
+      Puppet.expects(:info).with(regexp_matches(/starting applying configuration to/)).never
+      Puppet.expects(:err).with(regexp_matches(/Target device \/ certificate 'bla' not found in .*\.conf/))
+      expect { @device.main }.to exit_with 1
+    end
+
     it "should exit if the device list is empty" do
       expect { @device.main }.to exit_with 1
     end
@@ -360,6 +392,14 @@ describe Puppet::Application::Device do
         expect { @device.main }.to exit_with 0
       end
 
+      it "should make the Puppet::Pops::Loaaders available" do
+        @configurer.expects(:run).with(:network_device => true, :pluginsync => true) do
+          fail('Loaders not available') unless Puppet.lookup(:loaders) { nil }.is_a?(Puppet::Pops::Loaders)
+          true
+        end.at_least_once.returns(6,2)
+        expect { @device.main }.to exit_with 0
+      end
+
       it "exits 2 when --detailed-exitcodes and successful runs" do
         @device.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
         @configurer.stubs(:run).returns(0,2)
@@ -406,7 +446,6 @@ describe Puppet::Application::Device do
             Puppet.expects(:[]=).with(setting, make_absolute("/dummy")).in_sequence(seq)
           end
 
-
           expect { @device.main }.to exit_with 1
 
           expect(found_devices).to eq(all_devices)

data/spec/unit/application/face_base_spec.rb

@@ -341,9 +341,9 @@ describe Puppet::Application::FaceBase do
         end
       end
 
-      it "should render a non-trivially-keyed Hash with using pretty printed PSON" do
+      it "should render a non-trivially-keyed Hash with using pretty printed JSON" do
         hash = { [1,2] => 3, [2,3] => 5, [3,4] => 7 }
-        expect(app.render(hash, {})).to eq(PSON.pretty_generate(hash).chomp)
+        expect(app.render(hash, {})).to eq(JSON.pretty_generate(hash).chomp)
       end
 
       it "should render a {String,Numeric}-keyed Hash into a table" do
@@ -356,7 +356,7 @@ describe Puppet::Application::FaceBase do
         expect(app.render(hash, {})).to eq <<EOT
 5      5
 6.0    6
-four   #{object.to_pson.chomp}
+four   #{object.to_json.chomp}
 one    1
 three  {}
 two    []
@@ -406,7 +406,7 @@ EOT
         json = app.render({ :one => 1, :two => 2 }, {})
         expect(json).to match(/"one":\s*1\b/)
         expect(json).to match(/"two":\s*2\b/)
-        expect(PSON.parse(json)).to eq({ "one" => 1, "two" => 2 })
+        expect(JSON.parse(json)).to eq({ "one" => 1, "two" => 2 })
       end
     end
 
@@ -421,8 +421,8 @@ EOT
       expect { app.run }.to exit_with(1)
     end
 
-    it "should work if asked to render a NetworkHandler format" do
-      app.command_line.stubs(:args).returns %w{count_args a b c --render-as pson}
+    it "should work if asked to render json" do
+      app.command_line.stubs(:args).returns %w{count_args a b c --render-as json}
       expect {
         expect { app.run }.to exit_with(0)
       }.to have_printed(/3/)

data/spec/unit/application/lookup_spec.rb

@@ -59,7 +59,7 @@ describe Puppet::Application::Lookup do
       lookup.command_line.stubs(:args).returns(['atton', 'kreia'])
       lookup.stubs(:generate_scope).yields('scope')
 
-      expected_merge = { "strategy" => "deep", "sort_merged_arrays" => false, "merge_hash_arrays" => true }
+      expected_merge = { "strategy" => "deep", "sort_merge_arrays" => false, "merge_hash_arrays" => true }
 
       (Puppet::Pops::Lookup).expects(:lookup).with(['atton', 'kreia'], nil, nil, false, expected_merge, anything).returns('rand')
 
@@ -498,8 +498,6 @@ Searching for "a"
     end
 
     context 'the global scope' do
-      include PuppetSpec::Files
-
       it "is unaffected by global variables unless '--compile' is used" do
         lookup.options[:node] = node
         lookup.command_line.stubs(:args).returns(['c'])
@@ -512,34 +510,6 @@ Searching for "a"
         lookup.command_line.stubs(:args).returns(['c'])
         expect(run_lookup(lookup)).to eql("--- This is C from site.pp\n...")
       end
-
-      it 'receives extra facts in top scope' do
-        file_path = tmpdir('lookup_spec')
-        filename = File.join(file_path, "facts.yaml")
-        File.open(filename, "w+") { |f| f.write(<<-YAML.unindent) }
-          ---
-          cx: ' C from facts'
-          YAML
-
-        lookup.options[:node] = node
-        lookup.options[:fact_file] = filename
-        lookup.command_line.stubs(:args).returns(['c'])
-        expect(run_lookup(lookup)).to eql("--- This is C from facts\n...")
-      end
-
-      it 'receives extra facts in the facts hash' do
-        file_path = tmpdir('lookup_spec')
-        filename = File.join(file_path, "facts.yaml")
-        File.open(filename, "w+") { |f| f.write(<<-YAML.unindent) }
-          ---
-          cx: ' G from facts'
-        YAML
-
-        lookup.options[:node] = node
-        lookup.options[:fact_file] = filename
-        lookup.command_line.stubs(:args).returns(['g'])
-        expect(run_lookup(lookup)).to eql("--- This is G from facts in facts hash\n...")
-      end
     end
 
     context 'using a puppet function as data provider' do

data/spec/unit/application/master_spec.rb

@@ -13,7 +13,6 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
     Puppet::Util::Log.stubs(:newdestination)
 
     Puppet::Node.indirection.stubs(:terminus_class=)
-    Puppet::Node.indirection.stubs(:cache_class=)
     Puppet::Node::Facts.indirection.stubs(:terminus_class=)
     Puppet::Node::Facts.indirection.stubs(:cache_class=)
     Puppet::Transaction::Report.indirection.stubs(:terminus_class=)
@@ -206,10 +205,27 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
 
         @master.setup
       end
+    end
 
+    it "should not set Puppet[:node_cache_terminus] by default" do
+      # This is normally called early in the application lifecycle but in our
+      # spec testing we don't actually do a full application initialization so
+      # we call it here to validate the (possibly) overridden settings are as we
+      # expect
+      @master.initialize_app_defaults
+      @master.setup
 
+      expect(Puppet[:node_cache_terminus]).to be(nil)
     end
 
+    it "should honor Puppet[:node_cache_terminus] by setting the cache_class to its value" do
+      # PUP-6060 - ensure we honor this value if specified
+      @master.initialize_app_defaults
+      Puppet[:node_cache_terminus] = 'plain'
+      @master.setup
+
+      expect(Puppet::Node.indirection.cache_class).to eq(:plain)
+    end
   end
 
   describe "when running" do
@@ -244,15 +260,15 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
         expect { @master.compile }.to exit_with 0
       end
 
-      it "should convert the catalog to a pure-resource catalog and use 'PSON::pretty_generate' to pretty-print the catalog" do
+      it "should convert the catalog to a pure-resource catalog and use 'JSON::pretty_generate' to pretty-print the catalog" do
         catalog = Puppet::Resource::Catalog.new
-        PSON.stubs(:pretty_generate)
+        JSON.stubs(:pretty_generate)
         Puppet::Resource::Catalog.indirection.expects(:find).returns catalog
 
         catalog.expects(:to_resource).returns("rescat")
 
         @master.options[:node] = "foo"
-        PSON.expects(:pretty_generate).with('rescat', :allow_nan => true, :max_nesting => false)
+        JSON.expects(:pretty_generate).with('rescat', :allow_nan => true, :max_nesting => false)
 
         expect { @master.compile }.to exit_with 0
       end
@@ -339,7 +355,7 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
       end
 
       it "should log a deprecation notice when running a WEBrick server" do
-        Puppet.expects(:deprecation_warning).with("The WEBrick Puppet master server is deprecated and will be removed in a future release. Please use Puppet Server instead. See http://links.puppetlabs.com/deprecate-rack-webrick-servers for more information.")
+        Puppet.expects(:deprecation_warning).with("The WEBrick Puppet master server is deprecated and will be removed in a future release. Please use Puppet Server instead. See http://links.puppet.com/deprecate-rack-webrick-servers for more information.")
 
         @master.main
       end
@@ -378,7 +394,7 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
         end
 
         it "should log a deprecation notice" do
-          Puppet.expects(:deprecation_warning).with("The Rack Puppet master server is deprecated and will be removed in a future release. Please use Puppet Server instead. See http://links.puppetlabs.com/deprecate-rack-webrick-servers for more information.")
+          Puppet.expects(:deprecation_warning).with("The Rack Puppet master server is deprecated and will be removed in a future release. Please use Puppet Server instead. See http://links.puppet.com/deprecate-rack-webrick-servers for more information.")
 
           @master.main
         end

data/spec/unit/application/resource_spec.rb

@@ -175,4 +175,21 @@ describe Puppet::Application::Resource do
       @resource_app.main
     end
   end
+
+  describe 'when handling a custom type' do
+    it 'the Puppet::Pops::Loaders instance is available' do
+      Puppet::Type.newtype(:testing) do
+        newparam(:name) do
+          isnamevar
+        end
+        def self.instances
+          fail('Loader not found') unless Puppet::Pops::Loaders.find_loader(nil).is_a?(Puppet::Pops::Loader::Loader)
+          @instances ||= [new(:name => name)]
+        end
+      end
+      @resource_app.command_line.stubs(:args).returns(['testing', 'hello'])
+      @resource_app.expects(:puts).with { |args| expect(args).to eql("testing { 'hello':\n}") }
+      expect { @resource_app.main }.not_to raise_error
+    end
+  end
 end

data/spec/unit/application_spec.rb

@@ -65,12 +65,6 @@ describe Puppet::Application do
         @klass.find("ThisShallNeverEverEverExist")
       }.to raise_error(LoadError)
     end
-
-    it "#12114: should prevent File namespace collisions" do
-      # have to require the file face once, then the second time around it would fail
-      expect(@klass.find("File")).to eq(Puppet::Application::File)
-      expect(@klass.find("File")).to eq(Puppet::Application::File)
-    end
   end
 
   describe "#available_application_names" do
@@ -105,24 +99,6 @@ describe Puppet::Application do
     end
   end
 
-  describe ".environment_mode" do
-    it "should default to :local" do
-      expect(@appclass.get_environment_mode).to eq(:local)
-    end
-
-    it "should set and get a value" do
-      @appclass.environment_mode :remote
-      expect(@appclass.get_environment_mode).to eq(:remote)
-    end
-
-    it "should error if given a random symbol" do
-      expect{@appclass.environment_mode :foo}.to raise_error(/Invalid environment mode/)
-    end
-
-    it "should error if given a string" do
-      expect{@appclass.environment_mode 'local'}.to raise_error(/Invalid environment mode/)
-    end
-  end
 
 
   # These tests may look a little weird and repetative in its current state;

data/spec/unit/capability_spec.rb

@@ -9,7 +9,6 @@ describe 'Capability types' do
   let(:loaders) { Puppet::Pops::Loaders.new(env) }
 
   around :each do |example|
-    Puppet[:app_management] = true
     Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
     Puppet.override(:loaders => loaders, :current_environment => env) do
       Puppet::Type.newtype :cap, :is_capability => true do
@@ -19,7 +18,6 @@ describe 'Capability types' do
       example.run
       Puppet::Type.rmtype(:cap)
     end
-    Puppet[:app_management] = false
   end
 
   context 'annotations' do
@@ -402,10 +400,8 @@ test { one: hostname => "ahost", export => Cap[two] }
         ensure => directory
       }
 
-      if !defined(File["${same_dir}"]) {
-        file { $same_dir:
-          ensure => directory
-        }
+      file { $same_dir:
+        ensure => directory
       }
     PUPPET
 

data/spec/unit/configurer/fact_handler_spec.rb

@@ -69,51 +69,84 @@ describe Puppet::Configurer::FactHandler do
     end
   end
 
-  it "should serialize and CGI escape the fact values for uploading" do
-    facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
-    Puppet::Node::Facts.indirection.save(facts)
-    text = Puppet::Util.uri_query_encode(facthandler.find_facts.render(:pson))
+  context "when serializing" do
+    facts_with_special_characters = [
+      { :hash => { 'afact' => 'a+b' }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'a%2Bb' + '%22%7D' },
+      { :hash => { 'afact' => 'a b' }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'a%20b' + '%22%7D' },
+      { :hash => { 'afact' => 'a&b' }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'a%26b' + '%22%7D' },
+      { :hash => { 'afact' => 'a*b' }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'a%2Ab' + '%22%7D' },
+      { :hash => { 'afact' => 'a=b' }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'a%3Db' + '%22%7D' },
+      # different UTF-8 widths
+      # 1-byte A
+      # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
+      # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
+      # 4-byte 𠜎 - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
+      { :hash => { 'afact' => "A\u06FF\u16A0\u{2070E}" }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'A%DB%BF%E1%9A%A0%F0%A0%9C%8E' + '%22%7D' },
+    ]
+
+    context "as pson" do
+      before :each do
+        Puppet[:preferred_serialization_format] = 'pson'
+      end
+
+      it "should serialize and CGI escape the fact values for uploading" do
+        facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
+        Puppet::Node::Facts.indirection.save(facts)
+        text = Puppet::Util.uri_query_encode(facthandler.find_facts.render(:pson))
+
+        expect(text).to include('%22values%22%3A%7B%22my_name_fact%22%3A%22other_node_name%22%7D')
+        expect(facthandler.facts_for_uploading).to eq({:facts_format => :pson, :facts => text})
+      end
+
+      facts_with_special_characters.each do |test_fact|
+        it "should properly accept the fact #{test_fact[:hash]}" do
+          facts = Puppet::Node::Facts.new(Puppet[:node_name_value], test_fact[:hash])
+          Puppet::Node::Facts.indirection.save(facts)
+          text = Puppet::Util.uri_query_encode(facthandler.find_facts.render(:pson))
+
+          to_upload = facthandler.facts_for_uploading
+          expect(to_upload).to eq({:facts_format => :pson, :facts => text})
+          expect(text).to include(test_fact[:encoded])
+
+          # this is not sufficient to test whether these values are sent via HTTP GET or HTTP POST in actual catalog request
+          expect(JSON.parse(URI.unescape(to_upload[:facts]))['values']).to eq(test_fact[:hash])
+        end
+      end
+    end
 
-    expect(facthandler.facts_for_uploading).to eq({:facts_format => :pson, :facts => text})
-  end
+    context "as json" do
+      it "should serialize and CGI escape the fact values for uploading" do
+        facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
+        Puppet::Node::Facts.indirection.save(facts)
+        text = Puppet::Util.uri_query_encode(facthandler.find_facts.render(:json))
+
+        expect(text).to include('%22values%22%3A%7B%22my_name_fact%22%3A%22other_node_name%22%7D')
+        expect(facthandler.facts_for_uploading).to eq({:facts_format => 'application/json', :facts => text})
+      end
+
+      facts_with_special_characters.each do |test_fact|
+        it "should properly accept the fact #{test_fact[:hash]}" do
+          facts = Puppet::Node::Facts.new(Puppet[:node_name_value], test_fact[:hash])
+          Puppet::Node::Facts.indirection.save(facts)
+          text = Puppet::Util.uri_query_encode(facthandler.find_facts.render(:json))
+
+          to_upload = facthandler.facts_for_uploading
+          expect(to_upload).to eq({:facts_format => 'application/json', :facts => text})
+          expect(text).to include(test_fact[:encoded])
+
+          expect(JSON.parse(URI.unescape(to_upload[:facts]))['values']).to eq(test_fact[:hash])
+        end
+      end
+    end
 
-  [
-    { :hash => { 'afact' => 'a+b' }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'a%2Bb' + '%22%7D' },
-    { :hash => { 'afact' => 'a b' }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'a%20b' + '%22%7D' },
-    { :hash => { 'afact' => 'a&b' }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'a%26b' + '%22%7D' },
-    { :hash => { 'afact' => 'a*b' }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'a%2Ab' + '%22%7D' },
-    { :hash => { 'afact' => 'a=b' }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'a%3Db' + '%22%7D' },
-    # different UTF-8 widths
-    # 1-byte A
-    # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
-    # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
-    # 4-byte 𠜎 - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
-    { :hash => { 'afact' => "A\u06FF\u16A0\u{2070E}" }, :encoded => '%22values%22%3A%7B%22afact%22%3A%22' + 'A%DB%BF%E1%9A%A0%F0%A0%9C%8E' + '%22%7D' },
-
-  ].each do |test_fact|
-    it "should properly accept the fact #{test_fact[:hash]}" do
-      facts = Puppet::Node::Facts.new(Puppet[:node_name_value], test_fact[:hash])
+    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)
-      text = Puppet::Util.uri_query_encode(facthandler.find_facts.render(:pson))
-
-      to_upload = facthandler.facts_for_uploading
-      expect(to_upload).to eq({:facts_format => :pson, :facts => text})
-      expect(text).to include(test_fact[:encoded])
 
-      # this is not sufficient to test whether these values are sent via HTTP GET or HTTP POST in actual catalog request
-      expect(JSON.parse(URI.unescape(to_upload[:facts]))['values']).to eq(test_fact[:hash])
+      # prefer URI.unescape but validate CGI also works
+      encoded_facts = facthandler.facts_for_uploading[:facts]
+      expect(URI.unescape(encoded_facts)).to validate_against('api/schemas/facts.json')
+      expect(CGI.unescape(encoded_facts)).to validate_against('api/schemas/facts.json')
     end
   end
-
-  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)
-
-    # prefer URI.unescape but validate CGI also works
-    encoded_facts = facthandler.facts_for_uploading[:facts]
-    expect(URI.unescape(encoded_facts)).to validate_against('api/schemas/facts.json')
-    expect(CGI.unescape(encoded_facts)).to validate_against('api/schemas/facts.json')
-  end
-
 end
-