puppet 5.3.3-x86-mingw32 → 5.3.4-x86-mingw32

data/spec/unit/indirector/json_spec.rb

@@ -198,16 +198,5 @@ describe Puppet::Indirector::JSON do
       create_file('foo.json~', 'foo-backup')
       expect(subject.search(request('f*')).map(&:value)).to eq(['foo-json'])
     end
-
-    it "raises if the content contains binary" do
-      binary = "\xC0\xFF".force_encoding(Encoding::BINARY)
-
-      File.binwrite(subject.path('foo.json', ''), "foo-json")
-      File.binwrite(subject.path("foo#{binary}.bin", ''), "foo-binary")
-
-      expect {
-        subject.search(request('*'))
-      }.to raise_error Puppet::Error, /Could not parse JSON data/
-    end
   end
 end

data/spec/unit/indirector/node/exec_spec.rb

@@ -56,7 +56,7 @@ describe Puppet::Node::Exec do
     it "should set the resulting parameters as the node parameters" do
       @result[:parameters] = {"a" => "b", "c" => "d"}
       @searcher.find(request)
-      expect(@node.parameters).to eq({"a" => "b", "c" => "d"})
+      expect(@node.parameters).to eq({"a" => "b", "c" => "d", "environment" => "*root*"})
     end
 
     it "should set the resulting classes as the node classes" do

data/spec/unit/info_service_spec.rb

@@ -332,7 +332,7 @@ describe "Puppet::InfoService" do
        expect(result).to eq({
          "production"=>{
             "#{code_dir}/borked.pp"=>
-              {:error=>"Syntax error at '+' at #{code_dir}/borked.pp:1:30",
+              {:error=>"Syntax error at '+' (file: #{code_dir}/borked.pp, line: 1, column: 30)",
               },
             } # end production env
          })

data/spec/unit/interface_spec.rb

@@ -126,6 +126,18 @@ describe Puppet::Interface do
     expect { subject[:foo, '0.0.1'] }.to raise_error Puppet::Error
   end
 
+  describe 'when raising NoMethodErrors' do
+    subject { described_class.new(:foo, '1.0.0') }
+
+    it 'includes the face name in the error message' do
+      expect { subject.boombaz }.to raise_error(NoMethodError, /#{subject.name}/)
+    end
+
+    it 'includes the face version in the error message' do
+      expect { subject.boombaz }.to raise_error(NoMethodError, /#{subject.version}/)
+    end
+  end
+
   it_should_behave_like "things that declare options" do
     def add_options_to(&block)
       subject.new(:with_options, '0.0.1', &block)

data/spec/unit/module_spec.rb

@@ -227,8 +227,6 @@ describe Puppet::Module do
         tasks_dir = "#{mod_dir}/tasks"
         locale_dir = "#{mod_dir}/locales"
         Puppet::FileSystem.stubs(:exist?).with(metadata_file).returns true
-        # Skip checking for translation config file
-        Puppet::FileSystem.stubs(:exist?).with(locale_dir).returns false
       end
       mod = PuppetSpec::Modules.create(
         'test_gte_req',
@@ -445,31 +443,6 @@ describe Puppet::Module do
     end
   end
 
-
-  describe "initialize_i18n" do
-
-    let(:modpath) { tmpdir('modpath') }
-    let(:modname) { 'i18n' }
-    let(:modroot) { "#{modpath}/#{modname}/" }
-    let(:locale_dir) { "#{modroot}locales" }
-    let(:mod_obj) { PuppetSpec::Modules.create( modname, modpath, :metadata => { :dependencies => [] }, :env => env ) }
-
-    it "is expected to initialize an un-initialized module" do
-      expect(Puppet::GettextConfig.translations_loaded?("puppetlabs-#{modname}")).to be false
-
-      FileUtils.mkdir_p(locale_dir)
-      Puppet::FileSystem.stubs(:exist?).with(locale_dir).returns(true)
-
-      mod_obj.initialize_i18n
-
-      expect(Puppet::GettextConfig.translations_loaded?("puppetlabs-#{modname}")).to be true
-    end
-
-    it "is expected return nil if module is intiailized" do
-      expect(mod_obj.initialize_i18n).to be nil
-    end
-  end
-
   describe "when managing supported platforms" do
     it "should support specifying a supported platform" do
       mod.supports "solaris"
@@ -612,7 +585,6 @@ describe Puppet::Module do
 
       it "after the module is initialized" do
         Puppet::FileSystem.expects(:exist?).with(mod_tasks_dir).never
-        Puppet::GettextConfig.expects(:load_translations).returns(false)
         Puppet::Module::Task.expects(:tasks_in_module).never
         Puppet::Module.new(mod_name, @modpath, env)
       end

data/spec/unit/module_tool/tar/mini_spec.rb

@@ -8,10 +8,17 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
   let(:destfile)   { '/the/dest/file.tar.gz' }
   let(:minitar)    { described_class.new }
 
-  it "unpacks a tar file" do
-    unpacks_the_entry(:file_start, 'thefile')
+  class MockFileStatEntry
+    def initialize(mode = 0100)
+      @mode = mode
+    end
+  end
+
+  it "unpacks a tar file with correct permissions" do
+    entry = unpacks_the_entry(:file_start, 'thefile')
 
     minitar.unpack(sourcefile, destdir, 'uid')
+    expect(entry.instance_variable_get(:@mode)).to eq(0755)
   end
 
   it "does not allow an absolute path" do
@@ -41,20 +48,42 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
                      "Attempt to install file with an invalid path into \"#{File.expand_path('/the/thedir')}\" under \"#{destdir}\"")
   end
 
+  it "unpacks on Windows" do
+    unpacks_the_entry(:file_start, 'thefile', nil)
+
+    entry = minitar.unpack(sourcefile, destdir, 'uid')
+    # Windows does not use these permissions.
+    expect(entry.instance_variable_get(:@mode)).to eq(nil)
+  end
+
   it "packs a tar file" do
     writer = stub('GzipWriter')
 
     Zlib::GzipWriter.expects(:open).with(destfile).yields(writer)
-    Archive::Tar::Minitar.expects(:pack).with(sourcedir, writer)
+    stats = {:mode => 0222}
+    Archive::Tar::Minitar.expects(:pack).with(sourcedir, writer).yields(:file_start, 'abc', stats)
+
+    minitar.pack(sourcedir, destfile)
+  end
+
+  it "packs a tar file on Windows" do
+    writer = stub('GzipWriter')
+
+    Zlib::GzipWriter.expects(:open).with(destfile).yields(writer)
+    Archive::Tar::Minitar.expects(:pack).with(sourcedir, writer).
+        yields(:file_start, 'abc', {:entry => MockFileStatEntry.new(nil)})
 
     minitar.pack(sourcedir, destfile)
   end
 
-  def unpacks_the_entry(type, name)
+  def unpacks_the_entry(type, name, mode = 0100)
     reader = stub('GzipReader')
 
     Zlib::GzipReader.expects(:open).with(sourcefile).yields(reader)
     minitar.expects(:find_valid_files).with(reader).returns([name])
-    Archive::Tar::Minitar.expects(:unpack).with(reader, destdir, [name]).yields(type, name, nil)
+    entry = MockFileStatEntry.new(mode)
+    Archive::Tar::Minitar.expects(:unpack).with(reader, destdir, [name]).
+        yields(type, name, {:entry => entry})
+    entry
   end
 end

data/spec/unit/network/http/factory_spec.rb

@@ -94,5 +94,27 @@ describe Puppet::Network::HTTP::Factory do
         expect(conn.read_timeout).to eq(120)
       end
     end
+
+    context 'source address' do
+      it 'defaults to system-defined' do
+        skip "Requires Ruby >= 2.0" unless RUBY_VERSION.to_i >= 2
+        conn = create_connection(site)
+
+        expect(conn.local_host).to be(nil)
+      end
+
+      it 'sets the local_host address' do
+        Puppet[:sourceaddress] = "127.0.0.1"
+        if RUBY_VERSION.to_i >= 2
+          conn = create_connection(site)
+
+          expect(conn.local_host).to eq('127.0.0.1')
+        else
+          expect {
+            create_connection(site)
+          }.to raise_error(ArgumentError, "Setting 'sourceaddress' is unsupported by this version of Net::HTTP.")
+        end
+      end
+    end
   end
 end

data/spec/unit/network/http/webrick_spec.rb

@@ -14,31 +14,37 @@ describe Puppet::Network::HTTP::WEBrick do
 
   let(:address) { '127.0.0.1' }
   let(:port) { 31337 }
-
-  let(:server) do
-    s = Puppet::Network::HTTP::WEBrick.new
-    s.stubs(:setup_logger).returns(Hash.new)
-    s.stubs(:setup_ssl).returns(Hash.new)
-    s
-  end
+  let(:server) { Puppet::Network::HTTP::WEBrick.new }
+  let(:localcacert) { make_absolute("/ca/crt") }
+  let(:ssl_server_ca_auth) { make_absolute("/ca/ssl_server_auth_file") }
+  let(:key) { stub 'key', :content => "mykey" }
+  let(:cert) { stub 'cert', :content => "mycert" }
+  let(:host) { stub 'host', :key => key, :certificate => cert, :name => "yay", :ssl_store => "mystore" }
 
   let(:mock_ssl_context) do
     stub('ssl_context', :ciphers= => nil)
   end
 
+  let(:socket) { mock('socket') }
   let(:mock_webrick) do
-    stub('webrick',
-         :[] => {},
-         :listeners => [],
-         :status => :Running,
-         :mount => nil,
-         :start => nil,
-         :shutdown => nil,
-         :ssl_context => mock_ssl_context)
+    server = stub('webrick',
+                  :[] => {},
+                  :listeners => [],
+                  :status => :Running,
+                  :mount => nil,
+                  :shutdown => nil,
+                  :ssl_context => mock_ssl_context)
+    server.stubs(:start).yields(socket)
+    IO.stubs(:select).with([socket], nil, nil, anything).returns(true)
+    socket.stubs(:accept)
+    server.stubs(:run).with(socket)
+    server
   end
 
   before :each do
     WEBrick::HTTPServer.stubs(:new).returns(mock_webrick)
+    Puppet::SSL::Certificate.indirection.stubs(:find).with('ca').returns cert
+    Puppet::SSL::Host.stubs(:localhost).returns host
   end
 
   describe "when turning on listening" do
@@ -88,6 +94,13 @@ describe Puppet::Network::HTTP::WEBrick do
       expect(server).to be_listening
     end
 
+    it "is passed a yet to be accepted socket" do
+      socket.expects(:accept)
+
+      server.listen(address, port)
+      server.unlisten
+    end
+
     describe "when the REST protocol is requested" do
       it "should register the REST handler at /" do
         # We don't care about the options here.
@@ -192,18 +205,6 @@ describe Puppet::Network::HTTP::WEBrick do
   end
 
   describe "when configuring ssl" do
-    let(:server) { Puppet::Network::HTTP::WEBrick.new }
-    let(:localcacert) { make_absolute("/ca/crt") }
-    let(:ssl_server_ca_auth) { make_absolute("/ca/ssl_server_auth_file") }
-    let(:key) { stub 'key', :content => "mykey" }
-    let(:cert) { stub 'cert', :content => "mycert" }
-    let(:host) { stub 'host', :key => key, :certificate => cert, :name => "yay", :ssl_store => "mystore" }
-
-    before :each do
-      Puppet::SSL::Certificate.indirection.stubs(:find).with('ca').returns cert
-      Puppet::SSL::Host.stubs(:localhost).returns host
-    end
-
     it "should use the key from the localhost SSL::Host instance" do
       Puppet::SSL::Host.expects(:localhost).returns host
       host.expects(:key).returns key
@@ -236,8 +237,8 @@ describe Puppet::Network::HTTP::WEBrick do
       expect(server.setup_ssl[:SSLCACertificateFile]).to eq(ssl_server_ca_auth)
     end
 
-    it "should start ssl immediately" do
-      expect(server.setup_ssl[:SSLStartImmediately]).to be_truthy
+    it "should not start ssl immediately" do
+      expect(server.setup_ssl[:SSLStartImmediately]).to eq(false)
     end
 
     it "should enable ssl" do

data/spec/unit/node/environment_spec.rb

@@ -492,4 +492,20 @@ describe Puppet::Node::Environment do
     end
   end
 
+  describe "managing module translations" do
+    it "creates a new text domain the first time we try to use the text domain" do
+      Puppet::GettextConfig.expects(:reset_text_domain).with(env.name)
+      Puppet::ModuleTranslations.expects(:load_from_modulepath)
+
+      env.use_text_domain
+    end
+
+    it "uses the existing text domain once it has been created" do
+      env.use_text_domain
+
+      Puppet::GettextConfig.expects(:use_text_domain).with(env.name)
+      env.use_text_domain
+    end
+  end
+
 end

data/spec/unit/node_spec.rb

@@ -1,9 +1,11 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'matchers/json'
+require 'puppet_spec/files'
 
 describe Puppet::Node do
   include JSONMatchers
+  include PuppetSpec::Files
 
   let(:environment) { Puppet::Node::Environment.create(:bar, []) }
   let(:env_loader) { Puppet::Environments::Static.new(environment) }
@@ -115,8 +117,9 @@ describe Puppet::Node do
     end
 
     it "limits the serialization of environment to be just the name" do
-      # it is something like 138 when serializing everything in a default environment
-      expect(@node.to_yaml.size).to be < 70
+      yaml_file = file_containing("temp_yaml", @node.to_yaml)
+      node_yaml = Puppet::Util::Yaml.load_file(yaml_file, false, true)
+      expect(node_yaml['environment']).to eq('production')
     end
   end
 
@@ -155,6 +158,13 @@ describe Puppet::Node do
       expect(@node).to set_json_attribute('parameters').to({"a" => "b", "c" => "d"})
     end
 
+    it "does not include the environment parameter in the json" do
+      @node.parameters = {"a" => "b", "c" => "d"}
+      @node.environment = environment
+      expect(@node.parameters).to eq({"a"=>"b", "c"=>"d", "environment"=>"bar"})
+      expect(@node).to set_json_attribute('parameters').to({"a" => "b", "c" => "d"})
+    end
+
     it "does not include the parameters if there are none" do
       expect(@node).to_not set_json_attribute('parameters')
     end
@@ -186,12 +196,14 @@ describe Puppet::Node do
 
     it "includes parameters if set" do
       @node.parameters = {"a" => "b", "c" => "d"}
-      expect(Puppet::Node).to read_json_attribute('parameters').from(@node.to_json).as({"a" => "b", "c" => "d"})
+      expect(Puppet::Node).to read_json_attribute('parameters').from(@node.to_json).as({"a" => "b", "c" => "d", "environment" => "production"})
     end
 
     it "deserializes environment to environment_name as a symbol" do
-      @node.environment = environment
-      expect(Puppet::Node).to read_json_attribute('environment_name').from(@node.to_json).as(:bar)
+      Puppet.override(:environments => env_loader) do
+        @node.environment = environment
+        expect(Puppet::Node).to read_json_attribute('environment_name').from(@node.to_json).as(:bar)
+      end
     end
   end
 end
@@ -291,7 +303,10 @@ describe Puppet::Node, "when merging facts" do
 
   context "with an env loader" do
     let(:environment) { Puppet::Node::Environment.create(:one, []) }
-    let(:env_loader) { Puppet::Environments::Static.new(environment) }
+    let(:environment_two) { Puppet::Node::Environment.create(:two, []) }
+    let(:environment_three) { Puppet::Node::Environment.create(:three, []) }
+    let(:environment_prod) { Puppet::Node::Environment.create(:production, []) }
+    let(:env_loader) { Puppet::Environments::Static.new(environment, environment_two, environment_three, environment_prod) }
 
     around do |example|
       Puppet.override(:environments => env_loader) do
@@ -299,18 +314,89 @@ describe Puppet::Node, "when merging facts" do
       end
     end
 
-    it "adds the environment to the list of parameters" do
-      Puppet[:environment] = "one"
-      @node = Puppet::Node.new("testnode", :environment => "one")
-      @node.merge "two" => "three"
-      expect(@node.parameters["environment"]).to eq("one")
+    context "when a node is initialized from a data hash" do
+      context "when a node is initialzed with an environment" do
+        it "uses 'environment' when provided" do
+          my_node = Puppet::Node.from_data_hash("environment" => "one", "name" => "my_node")
+          expect(my_node.environment.name).to eq(:one)
+        end
+
+        it "uses the environment parameter when provided" do
+          my_node = Puppet::Node.from_data_hash("parameters" => {"environment" => "one"}, "name" => "my_node")
+          expect(my_node.environment.name).to eq(:one)
+        end
+
+        it "uses the environment when also given an environment parameter" do
+          my_node = Puppet::Node.from_data_hash("parameters" => {"environment" => "one"}, "name" => "my_node", "environment" => "two")
+          expect(my_node.environment.name).to eq(:two)
+        end
+
+        it "uses 'environment' when an environment fact has been merged" do
+          my_node = Puppet::Node.from_data_hash("environment" => "one", "name" => "my_node")
+          my_node.fact_merge Puppet::Node::Facts.new "my_node", "environment" => "two"
+          expect(my_node.environment.name).to eq(:one)
+        end
+
+        it "uses an environment parameter when an environment fact has been merged" do
+          my_node = Puppet::Node.from_data_hash("parameters" => {"environment" => "one"}, "name" => "my_node")
+          my_node.fact_merge Puppet::Node::Facts.new "my_node", "environment" => "two"
+          expect(my_node.environment.name).to eq(:one)
+        end
+
+        it "uses an environment when an environment parameter has been given and an environment fact has been merged" do
+          my_node = Puppet::Node.from_data_hash("parameters" => {"environment" => "two"}, "name" => "my_node", "environment" => "one")
+          my_node.fact_merge Puppet::Node::Facts.new "my_node", "environment" => "three"
+          expect(my_node.environment.name).to eq(:one)
+        end
+      end
+
+      context "when a node is initialized without an environment" do
+        it "should use the server's default environment" do
+          my_node = Puppet::Node.from_data_hash("name" => "my_node")
+          expect(my_node.environment.name).to eq(:production)
+        end
+
+        it "should use the server's default when an environment fact has been merged" do
+          my_node = Puppet::Node.from_data_hash("name" => "my_node")
+          my_node.fact_merge Puppet::Node::Facts.new "my_node", "environment" => "two"
+          expect(my_node.environment.name).to eq(:production)
+        end
+      end
     end
 
-    it "nots set the environment if it is already set in the parameters" do
-      Puppet[:environment] = "one"
-      @node = Puppet::Node.new("testnode", :environment => "one")
-      @node.merge "environment" => "two"
-      expect(@node.parameters["environment"]).to eq("two")
+    context "when a node is initialized from new" do
+
+      context "when a node is initialzed with an environment" do
+
+        it "adds the environment to the list of parameters" do
+          Puppet[:environment] = "one"
+          @node = Puppet::Node.new("testnode", :environment => "one")
+          @node.merge "two" => "three"
+          expect(@node.parameters["environment"]).to eq("one")
+        end
+
+        it "when merging, syncs the environment parameter to a node's existing environment" do
+          @node = Puppet::Node.new("testnode", :environment => "one")
+          @node.merge "environment" => "two"
+          expect(@node.parameters["environment"]).to eq("one")
+        end
+
+        it "merging facts does not override that environment" do
+          @node = Puppet::Node.new("testnode", :environment => "one")
+          @node.fact_merge Puppet::Node::Facts.new "testnode", "environment" => "two"
+          expect(@node.environment.name.to_s).to eq("one")
+        end
+      end
+
+      context "when a node is initialized without an environment" do
+
+        it "it perfers an environment name to an environment fact" do
+          @node = Puppet::Node.new("testnode")
+          @node.environment_name = "one"
+          @node.fact_merge Puppet::Node::Facts.new "testnode", "environment" => "two"
+          expect(@node.environment.name.to_s).to eq("one")
+        end
+      end
     end
   end
 end