puppet 3.7.1-x64-mingw32 → 3.7.2-x64-mingw32

data/spec/integration/parser/future_compiler_spec.rb

@@ -440,6 +440,16 @@ describe "Puppet::Parser::Compiler" do
         expect(catalog).to have_resource("Foo[test]").with_parameter(:x, 'say friend')
       end
 
+      it 'accepts undef as the default for an Optional argument' do
+        catalog = compile_to_catalog(<<-MANIFEST)
+          define foo(Optional[String] $x = undef) {
+            notify { "expected": message => $x == undef }
+          }
+          foo { 'test': }
+        MANIFEST
+        expect(catalog).to have_resource("Notify[expected]").with_parameter(:message, true)
+      end
+
       it 'accepts anything when parameters are untyped' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
@@ -458,6 +468,15 @@ describe "Puppet::Parser::Compiler" do
         end.to raise_error(/type Integer, got String/)
       end
 
+      it 'denies undef for a non-optional type' do
+        expect do
+          catalog = compile_to_catalog(<<-MANIFEST)
+            define foo(Integer $x) { }
+            foo { 'test': x => undef }
+          MANIFEST
+        end.to raise_error(/type Integer, got Undef/)
+      end
+
       it 'denies non type compliant default argument' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
@@ -467,6 +486,15 @@ describe "Puppet::Parser::Compiler" do
         end.to raise_error(/type Integer, got String/)
       end
 
+      it 'denies undef as the default for a non-optional type' do
+        expect do
+          catalog = compile_to_catalog(<<-MANIFEST)
+            define foo(Integer $x = undef) { }
+            foo { 'test':  }
+          MANIFEST
+        end.to raise_error(/type Integer, got Undef/)
+      end
+
       it 'accepts a Resource as a Type' do
         catalog = compile_to_catalog(<<-MANIFEST)
           define foo(Type[Bar] $x) {
@@ -489,6 +517,16 @@ describe "Puppet::Parser::Compiler" do
         expect(catalog).to have_resource("Class[Foo]").with_parameter(:x, 'say friend')
       end
 
+      it 'accepts undef as the default for an Optional argument' do
+        catalog = compile_to_catalog(<<-MANIFEST)
+          class foo(Optional[String] $x = undef) {
+            notify { "expected": message => $x == undef }
+          }
+          class { 'foo': }
+        MANIFEST
+        expect(catalog).to have_resource("Notify[expected]").with_parameter(:message, true)
+      end
+
       it 'accepts anything when parameters are untyped' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
@@ -507,6 +545,15 @@ describe "Puppet::Parser::Compiler" do
         end.to raise_error(/type Integer, got String/)
       end
 
+      it 'denies undef for a non-optional type' do
+        expect do
+          catalog = compile_to_catalog(<<-MANIFEST)
+            class foo(Integer $x) { }
+            class { 'foo': x => undef }
+          MANIFEST
+        end.to raise_error(/type Integer, got Undef/)
+      end
+
       it 'denies non type compliant default argument' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
@@ -516,6 +563,15 @@ describe "Puppet::Parser::Compiler" do
         end.to raise_error(/type Integer, got String/)
       end
 
+      it 'denies undef as the default for a non-optional type' do
+        expect do
+          catalog = compile_to_catalog(<<-MANIFEST)
+            class foo(Integer $x = undef) { }
+            class { 'foo':  }
+          MANIFEST
+        end.to raise_error(/type Integer, got Undef/)
+      end
+
       it 'accepts a Resource as a Type' do
         catalog = compile_to_catalog(<<-MANIFEST)
           class foo(Type[Bar] $x) {

data/spec/integration/type/user_spec.rb

@@ -8,7 +8,13 @@ describe Puppet::Type.type(:user), '(integration)', :unless => Puppet.features.m
   include PuppetSpec::Compiler
 
   context "when set to purge ssh keys from a file" do
-    let(:tempfile) { file_containing('user_spec', "# comment\nssh-rsa KEY-DATA key-name\nssh-rsa KEY-DATA key name\n") }
+    let(:tempfile) do
+      file_containing('user_spec', <<-EOF)
+        # comment
+        ssh-rsa KEY-DATA key-name
+        ssh-rsa KEY-DATA key name
+        EOF
+    end
     # must use an existing user, or the generated key resource
     # will fail on account of an invalid user for the key
     # - root should be a safe default
@@ -32,5 +38,20 @@ describe Puppet::Type.type(:user), '(integration)', :unless => Puppet.features.m
         File.read(tempfile).should_not =~ /key-name/
       end
     end
+
+    context "with multiple unnamed keys" do
+      let(:tempfile) do
+        file_containing('user_spec', <<-EOF)
+          # comment
+          ssh-rsa KEY-DATA1
+          ssh-rsa KEY-DATA2
+          EOF
+      end
+
+      it "should purge authorized ssh keys" do
+        apply_compiled_manifest(manifest)
+        File.read(tempfile).should_not =~ /KEY-DATA/
+      end
+    end
   end
 end

data/spec/lib/puppet_spec/files.rb

@@ -57,6 +57,7 @@ module PuppetSpec::Files
     dir_contained_in(tmpdir(name), contents_hash)
   end
 
+  def dir_contained_in(dir, contents_hash) PuppetSpec::Files.dir_contained_in(dir, contents_hash) end
   def self.dir_contained_in(dir, contents_hash)
     contents_hash.each do |k,v|
       if v.is_a?(Hash)

data/spec/unit/environments_spec.rb

@@ -97,6 +97,17 @@ describe Puppet::Environments do
       end
     end
 
+    it "raises error when environment not found" do
+      directory_tree = FS::MemoryFile.a_directory(File.expand_path("envdir"), [])
+
+      loader_from(:filesystem => [directory_tree],
+                  :directory => directory_tree) do |loader|
+        expect do
+          loader.get!("does_not_exist")
+        end.to raise_error(Puppet::Environments::EnvironmentNotFound)
+      end
+    end
+
     it "returns nil if an environment can't be found" do
       directory_tree = FS::MemoryFile.a_directory("envdir", [])
 
@@ -106,6 +117,17 @@ describe Puppet::Environments do
       end
     end
 
+    it "raises error if an environment can't be found" do
+      directory_tree = FS::MemoryFile.a_directory("envdir", [])
+
+      loader_from(:filesystem => [directory_tree],
+                  :directory => directory_tree) do |loader|
+        expect do
+          loader.get!("env_not_in_this_list")
+        end.to raise_error(Puppet::Environments::EnvironmentNotFound)
+      end
+    end
+
     context "with an environment.conf" do
       let(:envdir) do
         FS::MemoryFile.a_directory(File.expand_path("envdir"), [
@@ -295,6 +317,49 @@ config_version=$vardir/random/scripts
             with_config_version(File.expand_path('/some/script'))
         end
       end
+
+      it "should update environment settings if environment.conf has changed and timeout has expired" do
+        base_dir = File.expand_path("envdir")
+        original_envdir = FS::MemoryFile.a_directory(base_dir, [
+          FS::MemoryFile.a_directory("env3", [
+            FS::MemoryFile.a_regular_file_containing("environment.conf", <<-EOF)
+              manifest=/manifest_orig
+              modulepath=/modules_orig
+              environment_timeout=0
+            EOF
+          ]),
+        ])
+
+        FS.overlay(original_envdir) do
+          dir_loader = Puppet::Environments::Directories.new(original_envdir, [])
+          loader = Puppet::Environments::Cached.new(dir_loader)
+          Puppet.override(:environments => loader) do
+            original_env = loader.get("env3") # force the environment.conf to be read
+
+            changed_envdir = FS::MemoryFile.a_directory(base_dir, [
+              FS::MemoryFile.a_directory("env3", [
+                FS::MemoryFile.a_regular_file_containing("environment.conf", <<-EOF)
+                  manifest=/manifest_changed
+                  modulepath=/modules_changed
+                  environment_timeout=0
+                EOF
+              ]),
+            ])
+
+            FS.overlay(changed_envdir) do
+              changed_env = loader.get("env3")
+
+              expect(original_env).to environment(:env3).
+                with_manifest(File.expand_path("/manifest_orig")).
+                with_full_modulepath([File.expand_path("/modules_orig")])
+
+              expect(changed_env).to environment(:env3).
+                with_manifest(File.expand_path("/manifest_changed")).
+                with_full_modulepath([File.expand_path("/modules_changed")])
+            end
+          end
+        end
+      end
     end
   end
 
@@ -315,6 +380,12 @@ config_version=$vardir/random/scripts
       expect(loader.get(:doesnotexist)).to be_nil
     end
 
+    it "raises error if environment is not found" do
+      expect do
+        loader.get!(:doesnotexist)
+      end.to raise_error(Puppet::Environments::EnvironmentNotFound)
+    end
+
     it "gets a basic conf" do
       conf = loader.get_conf(:static1)
       expect(conf.modulepath).to eq('')
@@ -336,11 +407,34 @@ config_version=$vardir/random/scripts
     end
   end
 
+
+  describe "cached loaders" do
+    let(:cached1) { Puppet::Node::Environment.create(:cached1, []) }
+    let(:cached2) { Puppet::Node::Environment.create(:cached2, []) }
+    let(:static_loader) { Puppet::Environments::Static.new(cached1, cached2) }
+    let(:loader) { Puppet::Environments::Cached.new(static_loader) }
+
+    it "gets an environment" do
+      expect(loader.get(:cached2)).to eq(cached2)
+    end
+
+    it "returns nil if env not found" do
+      expect(loader.get(:doesnotexist)).to be_nil
+    end
+
+    it "raises error if environment is not found" do
+      expect do
+        loader.get!(:doesnotexist)
+      end.to raise_error(Puppet::Environments::EnvironmentNotFound)
+    end
+  end
+
   RSpec::Matchers.define :environment do |name|
     match do |env|
       env.name == name &&
         (!@manifest || @manifest == env.manifest) &&
         (!@modulepath || @modulepath == env.modulepath) &&
+        (!@full_modulepath || @full_modulepath == env.full_modulepath) &&
         (!@config_version || @config_version == env.config_version)
     end
 
@@ -352,6 +446,10 @@ config_version=$vardir/random/scripts
       @modulepath = modulepath
     end
 
+    chain :with_full_modulepath do |full_modulepath|
+      @full_modulepath = full_modulepath
+    end
+
     chain :with_config_version do |config_version|
       @config_version = config_version
     end
@@ -360,6 +458,7 @@ config_version=$vardir/random/scripts
       "environment #{expected}" +
         (@manifest ? " with manifest #{@manifest}" : "") +
         (@modulepath ? " with modulepath [#{@modulepath.join(', ')}]" : "") +
+        (@full_modulepath ? " with full_modulepath [#{@full_modulepath.join(', ')}]" : "") +
         (@config_version ? " with config_version #{@config_version}" : "")
     end
 

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

@@ -22,6 +22,10 @@ describe Puppet::Network::HTTP::WEBrick do
     s
   end
 
+  let(:mock_ssl_context) do
+    stub('ssl_context', :ciphers= => nil)
+  end
+
   let(:mock_webrick) do
     stub('webrick',
          :[] => {},
@@ -29,7 +33,8 @@ describe Puppet::Network::HTTP::WEBrick do
          :status => :Running,
          :mount => nil,
          :start => nil,
-         :shutdown => nil)
+         :shutdown => nil,
+         :ssl_context => mock_ssl_context)
   end
 
   before :each do
@@ -251,7 +256,15 @@ describe Puppet::Network::HTTP::WEBrick do
     end
 
     it "should reject SSLv2" do
-      server.setup_ssl[:SSLOptions].should == OpenSSL::SSL::OP_NO_SSLv2
+      options = server.setup_ssl[:SSLOptions]
+
+      expect(options & OpenSSL::SSL::OP_NO_SSLv2).to eq(OpenSSL::SSL::OP_NO_SSLv2)
+    end
+
+    it "should reject SSLv3" do
+      options = server.setup_ssl[:SSLOptions]
+
+      expect(options & OpenSSL::SSL::OP_NO_SSLv3).to eq(OpenSSL::SSL::OP_NO_SSLv3)
     end
 
     it "should configure the verification method as 'OpenSSL::SSL::VERIFY_PEER'" do
@@ -267,5 +280,11 @@ describe Puppet::Network::HTTP::WEBrick do
     it "should set the certificate name to 'nil'" do
       server.setup_ssl[:SSLCertName].should be_nil
     end
+
+    it "specifies the allowable ciphers" do
+      mock_ssl_context.expects(:ciphers=).with(server.class::CIPHERS)
+
+      server.create_server('localhost', '8888')
+    end
   end
 end

data/spec/unit/parser/compiler_spec.rb

@@ -1,6 +1,6 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
+require 'matchers/resource'
 
 class CompilerTestResource
   attr_accessor :builtin, :virtual, :evaluated, :type, :title
@@ -53,6 +53,7 @@ end
 
 describe Puppet::Parser::Compiler do
   include PuppetSpec::Files
+  include Matchers::Resource
 
   def resource(type, title)
     Puppet::Parser::Resource.new(type, title, :scope => @scope)
@@ -864,6 +865,23 @@ describe Puppet::Parser::Compiler do
         it "should fail if the class doesn't exist" do
           expect { compile_to_catalog('', node) }.to raise_error(Puppet::Error, /Could not find class something/)
         end
+
+        it 'evaluates classes declared with parameters before unparameterized classes' do
+          node = Puppet::Node.new('someone', :classes => { 'app::web' => {}, 'app' => { 'port' => 8080 } })
+          manifest = <<-MANIFEST
+          class app($port = 80) { }
+
+          class app::web($port = $app::port) inherits app {
+            notify { expected: message => "$port" }
+          }
+          MANIFEST
+
+          catalog = compile_to_catalog(manifest, node)
+
+          expect(catalog).to have_resource("Class[App]").with_parameter(:port, 8080)
+          expect(catalog).to have_resource("Class[App::Web]")
+          expect(catalog).to have_resource("Notify[expected]").with_parameter(:message, "8080")
+        end
       end
     end
   end

data/spec/unit/parser/functions/lookup_spec.rb

@@ -8,6 +8,7 @@ describe "lookup function" do
 
   before(:each) do
     Puppet[:binder] = true
+    Puppet[:parser] = 'future'
   end
 
   it "must be called with at least a name to lookup" do
@@ -46,9 +47,9 @@ describe "lookup function" do
     expect(scope.function_lookup(['a_value'])).to eq('from_hiera')
   end
 
-  it "returns :undef when the requested value is not bound and undef is accepted" do
+  it "returns nil when the requested value is not bound and undef is accepted" do
     scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
-    expect(scope.function_lookup(['not_bound_value',{'accept_undef' => true}])).to eq(:undef)
+    expect(scope.function_lookup(['not_bound_value',{'accept_undef' => true}])).to eq(nil)
   end
 
   it "fails if the requested value is not bound and undef is not allowed" do
@@ -84,35 +85,35 @@ describe "lookup function" do
 
   it "yields to a given lambda and returns the result" do
     scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
-    expect(scope.function_lookup(['a_value', ast_lambda('|$x|{something_else}')])).to eq('something_else')
+    expect(scope.function_lookup(['a_value', ast_lambda(scope, '|$x|{something_else}')])).to eq('something_else')
   end
 
   it "fails if given lambda produces undef" do
     scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
     expect do
-      scope.function_lookup(['a_value', ast_lambda('|$x|{undef}')])
+      scope.function_lookup(['a_value', ast_lambda(scope, '|$x|{undef}')])
     end.to raise_error(/did not find a value for the name 'a_value'/)
   end
 
   it "yields name and result to a given lambda" do
     scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
-    expect(scope.function_lookup(['a_value', ast_lambda('|$name, $result|{[$name, $result]}')])).to eq(['a_value', 'something'])
+    expect(scope.function_lookup(['a_value', ast_lambda(scope, '|$name, $result|{[$name, $result]}')])).to eq(['a_value', 'something'])
   end
 
   it "yields name and result and default to a given lambda" do
     scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
     expect(scope.function_lookup(['a_value', {'default' => 'cigar'}, 
-      ast_lambda('|$name, $result, $d|{[$name, $result, $d]}')])).to eq(['a_value', 'something', 'cigar'])
+      ast_lambda(scope, '|$name, $result, $d|{[$name, $result, $d]}')])).to eq(['a_value', 'something', 'cigar'])
   end
 
   it "yields to a given lambda and returns the result when giving name and type" do
     scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
-    expect(scope.function_lookup(['a_value', 'String', ast_lambda('|$x|{something_else}')])).to eq('something_else')
+    expect(scope.function_lookup(['a_value', 'String', ast_lambda(scope, '|$x|{something_else}')])).to eq('something_else')
   end
 
   it "yields :undef when value is not found and using a lambda" do
     scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
-    expect(scope.function_lookup(['not_bound_value', ast_lambda('|$x|{ if $x == undef {good} else {bad}}')])).to eq('good')
+    expect(scope.function_lookup(['not_bound_value', ast_lambda(scope, '|$x|{ if $x == undef {good} else {bad}}')])).to eq('good')
   end
 
   def scope_with_injections_from(binder)
@@ -137,10 +138,10 @@ describe "lookup function" do
     Puppet::Pops::Binder::Binder.new(layered_bindings)
   end
 
-  def ast_lambda(puppet_source)
+  def ast_lambda(scope, puppet_source)
     puppet_source = "fake_func() " + puppet_source
-    model = Puppet::Pops::Parser::EvaluatingParser.new().parse_string(puppet_source, __FILE__).current
-    model = model.body.lambda
-    Puppet::Pops::Model::AstTransformer.new(@file_source, nil).transform(model)
+    evaluator = Puppet::Pops::Parser::EvaluatingParser.new()
+    model = evaluator.parse_string(puppet_source, __FILE__).current
+    evaluator.closure(model.body.lambda, scope)
   end
 end