puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

data/spec/unit/network/http/rack/rest_spec.rb

@@ -12,11 +12,11 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
     before :all do
       @model_class = stub('indirected model class')
       Puppet::Indirector::Indirection.stubs(:model).with(:foo).returns(@model_class)
-      @handler = Puppet::Network::HTTP::RackREST.new(:handler => :foo)
     end
 
     before :each do
       @response = Rack::Response.new
+      @handler = Puppet::Network::HTTP::RackREST.new(:handler => :foo)
     end
 
     def mk_req(uri, opts = {})

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

@@ -0,0 +1,43 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/network/http'
+
+describe Puppet::Network::HTTP::Session do
+  let(:connection) { stub('connection') }
+
+  def create_session(connection, expiration_time = nil)
+    expiration_time ||= Time.now + 60 * 60
+
+    Puppet::Network::HTTP::Session.new(connection, expiration_time)
+  end
+
+  it 'provides access to its connection' do
+    session = create_session(connection)
+
+    session.connection.should == connection
+  end
+
+  it 'expires a connection whose expiration time is in the past' do
+    now = Time.now
+    past = now - 1
+
+    session = create_session(connection, past)
+    session.expired?(now).should be_true
+  end
+
+  it 'expires a connection whose expiration time is now' do
+    now = Time.now
+
+    session = create_session(connection, now)
+    session.expired?(now).should be_true
+  end
+
+  it 'does not expire a connection whose expiration time is in the future' do
+    now = Time.now
+    future = now + 1
+
+    session = create_session(connection, future)
+    session.expired?(now).should be_false
+  end
+end

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

@@ -0,0 +1,90 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/network/http'
+
+describe Puppet::Network::HTTP::Site do
+  let(:scheme)      { 'https' }
+  let(:host)        { 'rubygems.org' }
+  let(:port)        { 443 }
+
+  def create_site(scheme, host, port)
+    Puppet::Network::HTTP::Site.new(scheme, host, port)
+  end
+
+  it 'accepts scheme, host, and port' do
+    site = create_site(scheme, host, port)
+
+    expect(site.scheme).to eq(scheme)
+    expect(site.host).to eq(host)
+    expect(site.port).to eq(port)
+  end
+
+  it 'generates an external URI string' do
+    site = create_site(scheme, host, port)
+
+    expect(site.addr).to eq("https://rubygems.org:443")
+  end
+
+  it 'considers sites to be different when the scheme is different' do
+    https_site = create_site('https', host, port)
+    http_site = create_site('http', host, port)
+
+    expect(https_site).to_not eq(http_site)
+  end
+
+  it 'considers sites to be different when the host is different' do
+    rubygems_site = create_site(scheme, 'rubygems.org', port)
+    github_site = create_site(scheme, 'github.com', port)
+
+    expect(rubygems_site).to_not eq(github_site)
+  end
+
+  it 'considers sites to be different when the port is different' do
+    site_443 = create_site(scheme, host, 443)
+    site_80 = create_site(scheme, host, 80)
+
+    expect(site_443).to_not eq(site_80)
+  end
+
+  it 'compares values when determining equality' do
+    site = create_site(scheme, host, port)
+
+    sites = {}
+    sites[site] = site
+
+    another_site = create_site(scheme, host, port)
+
+    expect(sites.include?(another_site)).to be_true
+  end
+
+  it 'computes the same hash code for equivalent objects' do
+    site = create_site(scheme, host, port)
+    same_site = create_site(scheme, host, port)
+
+    expect(site.hash).to eq(same_site.hash)
+  end
+
+  it 'uses ssl with https' do
+    site = create_site('https', host, port)
+
+    expect(site).to be_use_ssl
+  end
+
+  it 'does not use ssl with http' do
+    site = create_site('http', host, port)
+
+    expect(site).to_not be_use_ssl
+  end
+
+  it 'moves to a new URI location' do
+    site = create_site('http', 'host1', 80)
+
+    uri = URI.parse('https://host2:443/some/where/else')
+    new_site = site.move_to(uri)
+
+    expect(new_site.scheme).to eq('https')
+    expect(new_site.host).to eq('host2')
+    expect(new_site.port).to eq(443)
+  end
+end

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

@@ -127,7 +127,7 @@ describe Puppet::Network::HTTP::WEBrick do
       server.setup_logger
     end
 
-    it "should use the masterlog if the run_mode is master" do
+    it "should use the masterhttplog if the run_mode is master" do
       Puppet.run_mode.stubs(:master?).returns(true)
       log = make_absolute("/master/log")
       Puppet[:masterhttplog] = log

data/spec/unit/network/http_pool_spec.rb

@@ -9,7 +9,6 @@ describe Puppet::Network::HttpPool do
   end
 
   describe "when managing http instances" do
-
     it "should return an http instance created with the passed host and port" do
       http = Puppet::Network::HttpPool.http_instance("me", 54321)
       http.should be_an_instance_of Puppet::Network::HTTP::Connection
@@ -47,7 +46,6 @@ describe Puppet::Network::HttpPool do
       Puppet::Network::HttpPool.http_instance("me", 54321, true).should be_use_ssl
     end
 
-
     describe 'peer verification' do
       def setup_standard_ssl_configuration
         ca_cert_file = File.expand_path('/path/to/ssl/certs/ca_cert.pem')
@@ -77,12 +75,18 @@ describe Puppet::Network::HttpPool do
         setup_standard_ssl_host
       end
 
-      it 'can enable peer verification' do
-        Puppet::Network::HttpPool.http_instance("me", 54321, true, true).send(:connection).verify_mode.should == OpenSSL::SSL::VERIFY_PEER
+      it 'enables peer verification by default' do
+        response = Net::HTTPOK.new('1.1', 200, 'body')
+        conn = Puppet::Network::HttpPool.http_instance("me", 54321, true)
+        conn.expects(:execute_request).with { |http, request| expect(http.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER) }.returns(response)
+        conn.get('/')
       end
 
       it 'can disable peer verification' do
-        Puppet::Network::HttpPool.http_instance("me", 54321, true, false).send(:connection).verify_mode.should == OpenSSL::SSL::VERIFY_NONE
+        response = Net::HTTPOK.new('1.1', 200, 'body')
+        conn = Puppet::Network::HttpPool.http_instance("me", 54321, true, false)
+        conn.expects(:execute_request).with { |http, request| expect(http.verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE) }.returns(response)
+        conn.get('/')
       end
     end
 
@@ -91,5 +95,4 @@ describe Puppet::Network::HttpPool do
         should_not equal(Puppet::Network::HttpPool.http_instance("me", 54321))
     end
   end
-
 end

data/spec/unit/network/http_spec.rb

@@ -0,0 +1,10 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/network/http'
+
+describe Puppet::Network::HTTP do
+  it 'defines an http_pool context' do
+    pool = Puppet.lookup(:http_pool)
+    expect(pool).to be_a(Puppet::Network::HTTP::NoCachePool)
+  end
+end

data/spec/unit/node/environment_spec.rb

@@ -187,6 +187,60 @@ describe Puppet::Node::Environment do
       end
     end
 
+    it "does not register conflicting_manifest_settings? when not using directory environments" do
+      expect(Puppet::Node::Environment.create(:directory, [], '/some/non/default/manifest.pp').conflicting_manifest_settings?).to be_false
+    end
+
+    describe "when operating in the context of directory environments" do
+      before(:each) do
+        Puppet[:environmentpath] = "$confdir/environments"
+        Puppet[:default_manifest] = "/default/manifests/site.pp"
+      end
+
+      it "has no conflicting_manifest_settings? when disable_per_environment_manifest is false" do
+        expect(Puppet::Node::Environment.create(:directory, [], '/some/non/default/manifest.pp').conflicting_manifest_settings?).to be_false
+      end
+
+      context "when disable_per_environment_manifest is true" do
+        let(:config) { mock('config') }
+        let(:global_modulepath) { ["/global/modulepath"] }
+        let(:envconf) { Puppet::Settings::EnvironmentConf.new("/some/direnv", config, global_modulepath) }
+
+        before(:each) do
+          Puppet[:disable_per_environment_manifest] = true
+        end
+
+        def assert_manifest_conflict(expectation, envconf_manifest_value)
+          config.expects(:setting).with(:manifest).returns(
+            mock('setting', :value => envconf_manifest_value)
+          )
+          environment = Puppet::Node::Environment.create(:directory, [], '/default/manifests/site.pp')
+          loader = Puppet::Environments::Static.new(environment)
+          loader.stubs(:get_conf).returns(envconf)
+
+          Puppet.override(:environments => loader) do
+            expect(environment.conflicting_manifest_settings?).to eq(expectation)
+          end
+        end
+
+        it "has conflicting_manifest_settings when environment.conf manifest was set" do
+          assert_manifest_conflict(true, '/some/envconf/manifest/site.pp')
+        end
+
+        it "does not have conflicting_manifest_settings when environment.conf manifest is empty" do
+          assert_manifest_conflict(false, '')
+        end
+
+        it "does not have conflicting_manifest_settings when environment.conf manifest is nil" do
+          assert_manifest_conflict(false, nil)
+        end
+
+        it "does not have conflicting_manifest_settings when environment.conf manifest is an exact, uninterpolated match of default_manifest" do
+          assert_manifest_conflict(false, '/default/manifests/site.pp')
+        end
+      end
+    end
+
     describe "when modeling a specific environment" do
       it "should have a method for returning the environment name" do
         Puppet::Node::Environment.new("testing").name.should == :testing

data/spec/unit/node_spec.rb

@@ -157,11 +157,9 @@ describe Puppet::Node do
       Puppet::Node.should read_json_attribute('parameters').from(@node.to_pson).as({"a" => "b", "c" => "d"})
     end
 
-    it "should include the environment" do
-      Puppet.override(:environments => env_loader) do
-        @node.environment = environment
-        Puppet::Node.should read_json_attribute('environment').from(@node.to_pson).as(environment)
-      end
+    it "deserializes environment to environment_name as a string" do
+      @node.environment = environment
+      Puppet::Node.should read_json_attribute('environment_name').from(@node.to_pson).as('bar')
     end
   end
 end

data/spec/unit/parser/compiler_spec.rb

@@ -97,6 +97,13 @@ describe Puppet::Parser::Compiler do
     @compiler.environment.should equal(@node.environment)
   end
 
+  it "fails if the node's environment has conflicting manifest settings" do
+    conflicted_environment = Puppet::Node::Environment.create(:testing, [], '/some/environment.conf/manifest.pp')
+    conflicted_environment.stubs(:conflicting_manifest_settings?).returns(true)
+    @node.environment = conflicted_environment
+    expect { Puppet::Parser::Compiler.compile(@node) }.to raise_error(Puppet::Error, /disable_per_environment_manifest.*true.*environment.conf.*manifest.*conflict/)
+  end
+
   it "should include the resource type collection helper" do
     Puppet::Parser::Compiler.ancestors.should be_include(Puppet::Resource::TypeCollectionHelper)
   end
@@ -681,7 +688,7 @@ describe Puppet::Parser::Compiler do
     it "should skip classes that have already been evaluated" do
       @compiler.catalog.stubs(:tag)
 
-      @scope.stubs(:class_scope).with(@class).returns("something")
+      @scope.stubs(:class_scope).with(@class).returns(@scope)
 
       @compiler.expects(:add_resource).never
 
@@ -694,7 +701,7 @@ describe Puppet::Parser::Compiler do
     it "should skip classes previously evaluated with different capitalization" do
       @compiler.catalog.stubs(:tag)
       @scope.stubs(:find_hostclass).with("MyClass",{:assume_fqname => false}).returns(@class)
-      @scope.stubs(:class_scope).with(@class).returns("something")
+      @scope.stubs(:class_scope).with(@class).returns(@scope)
       @compiler.expects(:add_resource).never
       @resource.expects(:evaluate).never
       Puppet::Parser::Resource.expects(:new).never

data/spec/unit/parser/files_spec.rb

@@ -12,6 +12,25 @@ describe Puppet::Parser::Files do
     @basepath = make_absolute("/somepath")
   end
 
+  describe "when searching for files" do
+    it "should return fully-qualified files directly" do
+      Puppet::Parser::Files.expects(:modulepath).never
+      Puppet::Parser::Files.find_file(@basepath + "/my/file", environment).should == @basepath + "/my/file"
+    end
+
+    it "should return the first found file" do
+      mod = mock 'module'
+      mod.expects(:file).returns("/one/mymod/files/myfile")
+      environment.expects(:module).with("mymod").returns mod
+
+      Puppet::Parser::Files.find_file("mymod/myfile", environment).should == "/one/mymod/files/myfile"
+    end
+
+    it "should return nil if template is not found" do
+      Puppet::Parser::Files.find_file("foomod/myfile", environment).should be_nil
+    end
+  end
+
   describe "when searching for templates" do
     it "should return fully-qualified templates directly" do
       Puppet::Parser::Files.expects(:modulepath).never

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

@@ -3,11 +3,15 @@ require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'puppet/parser/functions'
 require 'matchers/containment_matchers'
+require 'matchers/resource'
 require 'matchers/include_in_order'
+require 'unit/parser/functions/shared'
+
 
 describe 'The "contain" function' do
   include PuppetSpec::Compiler
   include ContainmentMatchers
+  include Matchers::Resource
 
   it "includes the class" do
     catalog = compile_to_catalog(<<-MANIFEST)
@@ -25,6 +29,41 @@ describe 'The "contain" function' do
     expect(catalog.classes).to include("contained")
   end
 
+  it "includes the class when using a fully qualified anchored name" do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class contained {
+        notify { "contained": }
+      }
+
+      class container {
+        contain ::contained
+      }
+
+      include container
+    MANIFEST
+
+    expect(catalog.classes).to include("contained")
+  end
+
+  it "ensures that the edge is with the correct class" do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class outer {
+        class named { }
+        contain named
+      }
+
+      class named { }
+
+      include named
+      include outer
+    MANIFEST
+
+    expect(catalog).to have_resource("Class[Named]")
+    expect(catalog).to have_resource("Class[Outer]")
+    expect(catalog).to have_resource("Class[Outer::Named]")
+    expect(catalog).to contain_class("outer::named").in("outer")
+  end
+
   it "makes the class contained in the current class" do
     catalog = compile_to_catalog(<<-MANIFEST)
       class contained {
@@ -182,4 +221,16 @@ describe 'The "contain" function' do
       )
     end
   end
+
+  describe "When the future parser is in use" do
+    require 'puppet/pops'
+    before(:each) do
+      Puppet[:parser] = 'future'
+      compiler  = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
+      @scope = Puppet::Parser::Scope.new(compiler)
+    end
+
+    it_should_behave_like 'all functions transforming relative to absolute names', :function_contain
+    it_should_behave_like 'an inclusion function, regardless of the type of class reference,', :contain
+  end
 end

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

@@ -49,7 +49,7 @@ describe 'function for dynamically creating resources' do
     end
 
     it 'should be able to add exported resources' do
-      catalog = compile_to_catalog("create_resources('@@file', {'/etc/foo'=>{'ensure'=>'present'}})")
+      catalog = compile_to_catalog("create_resources('@@file', {'/etc/foo'=>{'ensure'=>'present'}}) realize(File['/etc/foo'])")
       catalog.resource(:file, "/etc/foo")['ensure'].should == 'present'
       catalog.resource(:file, "/etc/foo").exported.should == true
     end
@@ -202,5 +202,12 @@ describe 'function for dynamically creating resources' do
       catalog.resource(:notify, "test")['message'].should == 'two'
       catalog.resource(:class, "bar").should_not be_nil
     end
+
+    it 'should fail with a correct error message if the syntax of an imported file is incorrect' do
+      expect{
+        Puppet[:modulepath] = my_fixture_dir
+        compile_to_catalog('include foo')
+      }.to raise_error(Puppet::Error, /Syntax error at.*/)
+    end
   end
 end

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

@@ -0,0 +1,31 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+
+describe "the digest function", :uses_checksums => true do
+  before :all do
+    Puppet::Parser::Functions.autoloader.loadall
+  end
+
+  before :each do
+    n = Puppet::Node.new('unnamed')
+    c = Puppet::Parser::Compiler.new(n)
+    @scope = Puppet::Parser::Scope.new(c)
+  end
+
+  it "should exist" do
+    Puppet::Parser::Functions.function("digest").should == "function_digest"
+  end
+
+  with_digest_algorithms do
+    it "should use the proper digest function" do
+      result = @scope.function_digest([plaintext])
+      result.should(eql( checksum ))
+    end
+
+    it "should only accept one parameter" do
+      expect do
+        @scope.function_digest(['foo', 'bar'])
+      end.to raise_error(ArgumentError)
+    end
+  end
+end