puppet 3.4.3 → 3.5.0.rc1

data/spec/integration/indirector/direct_file_server_spec.rb

@@ -15,7 +15,7 @@ describe Puppet::Indirector::DirectFileServer, " when interacting with the files
 
   it "should return an instance of the model" do
     pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
-      Puppet::FileSystem::File.expects(:exist?).with(@filepath).returns(true)
+      Puppet::FileSystem.expects(:exist?).with(@filepath).returns(true)
 
       @terminus.find(@terminus.indirection.request(:find, "file://host#{@filepath}", nil)).should be_instance_of(Puppet::FileServing::Content)
     end

data/spec/integration/indirector/file_content/file_server_spec.rb

@@ -28,10 +28,9 @@ describe Puppet::Indirector::FileContent::FileServer, " when finding files" do
 
     Puppet.settings[:modulepath] = "/no/such/file"
 
-    env = Puppet::Node::Environment.new("foo")
-    env.stubs(:modulepath).returns [path]
+    env = Puppet::Node::Environment.create(:foo, [path], '')
 
-    result = Puppet::FileServing::Content.indirection.search("plugins", :environment => "foo", :recurse => true)
+    result = Puppet::FileServing::Content.indirection.search("plugins", :environment => env, :recurse => true)
 
     result.should_not be_nil
     result.length.should == 2
@@ -59,8 +58,8 @@ describe Puppet::Indirector::FileContent::FileServer, " when finding files" do
   end
 
   it "should find file content in files when node name expansions are used" do
-    Puppet::FileSystem::File.stubs(:exist?).returns true
-    Puppet::FileSystem::File.stubs(:exist?).with(Puppet[:fileserverconfig]).returns(true)
+    Puppet::FileSystem.stubs(:exist?).returns true
+    Puppet::FileSystem.stubs(:exist?).with(Puppet[:fileserverconfig]).returns(true)
 
     @path = tmpfile("file_server_testing")
 

data/spec/integration/network/authconfig_spec.rb

@@ -7,7 +7,7 @@ RSpec::Matchers.define :allow do |params|
 
   match do |auth|
     begin
-      auth.check_authorization(params[0], params[1], params[2], params[3])
+      auth.check_authorization(*params)
       true
     rescue Puppet::Network::AuthorizationError
       false
@@ -15,11 +15,11 @@ RSpec::Matchers.define :allow do |params|
   end
 
   failure_message_for_should do |instance|
-    "expected #{params[3][:node]}/#{params[3][:ip]} to be allowed"
+    "expected #{params[2][:node]}/#{params[2][:ip]} to be allowed"
   end
 
   failure_message_for_should_not do |instance|
-    "expected #{params[3][:node]}/#{params[3][:ip]} to be forbidden"
+    "expected #{params[2][:node]}/#{params[2][:ip]} to be forbidden"
   end
 end
 
@@ -54,7 +54,7 @@ describe Puppet::Network::AuthConfig do
       :ip => '10.1.1.1',
       :authenticated => true
     }.merge(args)
-    ['test', :find, args[:key], args]
+    [:find, "/test/#{args[:key]}", args]
   end
 
   describe "allow" do

data/spec/integration/network/formats_spec.rb

@@ -9,7 +9,7 @@ class PsonIntTest
     other.class == self.class and string == other.string
   end
 
-  def self.from_pson(data)
+  def self.from_data_hash(data)
     new(data[0])
   end
 

data/spec/integration/node/environment_spec.rb

@@ -2,9 +2,19 @@
 require 'spec_helper'
 
 require 'puppet_spec/files'
+require 'puppet_spec/scope'
+require 'matchers/resource'
 
 describe Puppet::Node::Environment do
   include PuppetSpec::Files
+  include Matchers::Resource
+
+  def a_module_in(name, dir)
+    Dir.mkdir(dir)
+    moddir = File.join(dir, name)
+    Dir.mkdir(moddir)
+    moddir
+  end
 
   it "should be able to return each module from its environment with the environment, name, and path set correctly" do
     base = tmpfile("env_modules")
@@ -15,15 +25,11 @@ describe Puppet::Node::Environment do
     %w{1 2}.each do |num|
       dir = File.join(base, "dir#{num}")
       dirs << dir
-      Dir.mkdir(dir)
-      mod = "mod#{num}"
-      moddir = File.join(dir, mod)
-      mods[mod] = moddir
-      Dir.mkdir(moddir)
+
+      mods["mod#{num}"] = a_module_in("mod#{num}", dir)
     end
 
-    environment = Puppet::Node::Environment.new("foo")
-    environment.stubs(:modulepath).returns dirs
+    environment = Puppet::Node::Environment.create(:foo, dirs, '')
 
     environment.modules.each do |mod|
       mod.environment.should == environment
@@ -36,22 +42,68 @@ describe Puppet::Node::Environment do
     Dir.mkdir(base)
 
     dirs = []
-    mods = {}
     %w{1 2}.each do |num|
       dir = File.join(base, "dir#{num}")
       dirs << dir
-      Dir.mkdir(dir)
-      mod = "mod"
-      moddir = File.join(dir, mod)
-      mods[mod] = moddir
-      Dir.mkdir(moddir)
+
+      a_module_in("mod", dir)
     end
 
-    environment = Puppet::Node::Environment.new("foo")
-    environment.stubs(:modulepath).returns dirs
+    environment = Puppet::Node::Environment.create(:foo, dirs, '')
 
     mods = environment.modules
     mods.length.should == 1
     mods[0].path.should == File.join(base, "dir1", "mod")
   end
+
+  shared_examples_for "the environment's initial import" do |settings|
+    it "a manifest referring to a directory invokes parsing of all its files in sorted order" do
+      settings.each do |name, value|
+        Puppet[name] = value
+      end
+
+      # fixture has three files 00_a.pp, 01_b.pp, and 02_c.pp. The 'b' file
+      # depends on 'a' being evaluated first. The 'c' file is empty (to ensure
+      # empty things do not break the directory import).
+      #
+      dirname = my_fixture('sitedir')
+
+      # Set the manifest to the directory to make it parse and combine them when compiling
+      node = Puppet::Node.new('testnode',
+                              :environment => Puppet::Node::Environment.create(:testing, [], dirname))
+
+      catalog = Puppet::Parser::Compiler.compile(node)
+
+      expect(catalog).to have_resource('Class[a]')
+      expect(catalog).to have_resource('Class[b]')
+      expect(catalog).to have_resource('Notify[variables]').with_parameter(:message, "a: 10, b: 10")
+    end
+  end
+
+  describe 'using classic parser' do
+    it_behaves_like "the environment's initial import",
+      :parser => 'current',
+      # fixture uses variables that are set in a particular order (this ensures
+      # that files are parsed and combined in the right order or an error will
+      # be raised if 'b' is evaluated before 'a').
+      :strict_variables => true
+  end
+
+  describe 'using future parser' do
+    it_behaves_like "the environment's initial import",
+      :parser    => 'future',
+      :evaluator => 'future',
+      # Turned off because currently future parser turns on the binder which
+      # causes lookup of facts that are uninitialized and it will fail with
+      # errors for 'osfamily' etc.  This can be turned back on when the binder
+      # is taken out of the equation.
+      :strict_variables => false
+
+    context 'and evaluator current' do
+      it_behaves_like "the environment's initial import",
+        :parser           => 'future',
+        :evaluator        => 'current',
+        :strict_variables => false
+    end
+  end
 end

data/spec/integration/node/facts_spec.rb

@@ -23,7 +23,7 @@ describe Puppet::Node::Facts do
       terminus = Puppet::Node::Facts.indirection.terminus(:yaml)
 
       terminus.expects(:path).with("me").returns "/my/yaml/file"
-      Puppet::FileSystem::File.expects(:exist?).with("/my/yaml/file").returns false
+      Puppet::FileSystem.expects(:exist?).with("/my/yaml/file").returns false
 
       Puppet::Node::Facts.indirection.find("me").should be_nil
     end

data/spec/integration/node_spec.rb

@@ -21,7 +21,7 @@ describe Puppet::Node do
 
       terminus.expects(:path).with(@name).returns "/my/yaml/file"
 
-      Puppet::FileSystem::File.expects(:exist?).with("/my/yaml/file").returns false
+      Puppet::FileSystem.expects(:exist?).with("/my/yaml/file").returns false
       Puppet::Node.indirection.find(@name).should be_nil
     end
 

data/spec/integration/parser/catalog_spec.rb

@@ -3,73 +3,113 @@ require 'matchers/include_in_order'
 require 'puppet_spec/compiler'
 require 'puppet/indirector/catalog/compiler'
 
-describe "Transmission of the catalog to the agent" do
+describe "A catalog" do
   include PuppetSpec::Compiler
 
-  it "preserves the order in which the resources are added to the catalog" do
-    resources_in_declaration_order = ["Class[First]",
-                                      "Second[position]",
-                                      "Class[Third]",
-                                      "Fourth[position]"]
-
-    master_catalog, agent_catalog = master_and_agent_catalogs_for(<<-EOM)
-      define fourth() { }
-      class third { }
-
-      define second() {
-        fourth { "position": }
-      }
-
-      class first {
-        second { "position": }
-        class { "third": }
-      }
-
-      include first
-    EOM
-
-    expect(resources_in(master_catalog)).
-      to include_in_order(*resources_in_declaration_order)
-    expect(resources_in(agent_catalog)).
-      to include_in_order(*resources_in_declaration_order)
+  shared_examples_for "when compiled" do
+    context "when transmitted to the agent" do
+
+      it "preserves the order in which the resources are added to the catalog" do
+        resources_in_declaration_order = ["Class[First]",
+                                          "Second[position]",
+                                          "Class[Third]",
+                                          "Fourth[position]"]
+
+        master_catalog, agent_catalog = master_and_agent_catalogs_for(<<-EOM)
+          define fourth() { }
+          class third { }
+
+          define second() {
+            fourth { "position": }
+          }
+
+          class first {
+            second { "position": }
+            class { "third": }
+          }
+
+          include first
+        EOM
+
+        expect(resources_in(master_catalog)).
+          to include_in_order(*resources_in_declaration_order)
+        expect(resources_in(agent_catalog)).
+          to include_in_order(*resources_in_declaration_order)
+      end
+
+      it "does not contain unrealized, virtual resources" do
+        virtual_resources = ["Unrealized[unreal]", "Class[Unreal]"]
+
+        master_catalog, agent_catalog = master_and_agent_catalogs_for(<<-EOM)
+          class unreal { }
+          define unrealized() { }
+
+          class real {
+            @unrealized { "unreal": }
+            @class { "unreal": }
+          }
+
+          include real
+        EOM
+
+        expect(resources_in(master_catalog)).to_not include(*virtual_resources)
+        expect(resources_in(agent_catalog)).to_not include(*virtual_resources)
+      end
+
+      it "does not contain unrealized, exported resources" do
+        exported_resources = ["Unrealized[unreal]", "Class[Unreal]"]
+
+        master_catalog, agent_catalog = master_and_agent_catalogs_for(<<-EOM)
+          class unreal { }
+          define unrealized() { }
+
+          class real {
+            @@unrealized { "unreal": }
+            @@class { "unreal": }
+          }
+
+          include real
+        EOM
+
+        expect(resources_in(master_catalog)).to_not include(*exported_resources)
+        expect(resources_in(agent_catalog)).to_not include(*exported_resources)
+      end
+    end
+
+    it "compiles resource creation from appended array as two separate resources" do
+      # moved here from acceptance test "jeff_append_to_array.rb"
+      master_catalog = master_catalog_for(<<-EOM)
+        class parent {
+          $arr1 = [ "parent array element" ]
+        }
+        class parent::child inherits parent {
+          $arr1 += ["child array element"]
+          notify { $arr1: }
+        }
+        include parent::child
+      EOM
+      expect(resources_in(master_catalog)).to include('Notify[parent array element]', 'Notify[child array element]')
+    end
   end
 
-  it "does not contain unrealized, virtual resources" do
-    virtual_resources = ["Unrealized[unreal]", "Class[Unreal]"]
-
-    master_catalog, agent_catalog = master_and_agent_catalogs_for(<<-EOM)
-      class unreal { }
-      define unrealized() { }
-
-      class real {
-        @unrealized { "unreal": }
-        @class { "unreal": }
-      }
-
-      include real
-    EOM
-
-    expect(resources_in(master_catalog)).to_not include(*virtual_resources)
-    expect(resources_in(agent_catalog)).to_not include(*virtual_resources)
+  describe 'using classic parser' do
+    before :each do
+      Puppet[:parser] = 'current'
+    end
+    it_behaves_like 'when compiled' do
+    end
   end
 
-  it "does not contain unrealized, exported resources" do
-    exported_resources = ["Unrealized[unreal]", "Class[Unreal]"]
-
-    master_catalog, agent_catalog = master_and_agent_catalogs_for(<<-EOM)
-      class unreal { }
-      define unrealized() { }
-
-      class real {
-        @@unrealized { "unreal": }
-        @@class { "unreal": }
-      }
-
-      include real
-    EOM
+  describe 'using future parser' do
+    before :each do
+      Puppet[:parser] = 'future'
+    end
+    it_behaves_like 'when compiled' do
+    end
+  end
 
-    expect(resources_in(master_catalog)).to_not include(*exported_resources)
-    expect(resources_in(agent_catalog)).to_not include(*exported_resources)
+  def master_catalog_for(manifest)
+    master_catalog = Puppet::Resource::Catalog::Compiler.new.filter(compile_to_catalog(manifest))
   end
 
   def master_and_agent_catalogs_for(manifest)

data/spec/integration/parser/compiler_spec.rb

@@ -2,9 +2,11 @@
 require 'spec_helper'
 require 'puppet/parser/parser_factory'
 require 'puppet_spec/compiler'
+require 'matchers/resource'
 
 describe "Puppet::Parser::Compiler" do
   include PuppetSpec::Compiler
+  include Matchers::Resource
 
   before :each do
     @node = Puppet::Node.new "testnode"
@@ -138,7 +140,7 @@ describe "Puppet::Parser::Compiler" do
     end
 
     ['class', 'define', 'node'].each do |thing|
-      it "should not allow #{thing} inside evaluated conditional constructs" do
+      it "should not allow '#{thing}' inside evaluated conditional constructs" do
         Puppet[:code] = <<-PP
           if true {
             #{thing} foo {
@@ -314,6 +316,105 @@ describe "Puppet::Parser::Compiler" do
       end
     end
 
+    context 'when working with immutable node data' do
+      context 'and have opted in to immutable_node_data' do
+        before :each do
+          Puppet[:immutable_node_data] = true
+        end
+
+        def node_with_facts(facts)
+          Puppet[:facts_terminus] = :memory
+          Puppet::Node::Facts.indirection.save(Puppet::Node::Facts.new("testing", facts))
+          node = Puppet::Node.new("testing")
+          node.fact_merge
+          node
+        end
+
+        matcher :fail_compile_with do |node, message_regex|
+          match do |manifest|
+            @error = nil
+            begin
+              compile_to_catalog(manifest, node)
+              false
+            rescue Puppet::Error => e
+              @error = e
+              message_regex.match(e.message)
+            end
+          end
+
+          failure_message_for_should do
+            if @error
+              "failed with #{@error}\n#{@error.backtrace}"
+            else
+              "did not fail"
+            end
+          end
+        end
+
+        it 'should make $facts available' do
+          node = node_with_facts('the_facts' => 'straight')
+
+          catalog = compile_to_catalog(<<-MANIFEST, node)
+           notify { 'test': message => $facts[the_facts] }
+          MANIFEST
+
+          catalog.resource("Notify[test]")[:message].should == "straight"
+        end
+
+        it 'should make $facts reserved' do
+          node = node_with_facts('the_facts' => 'straight')
+
+          expect('$facts = {}').to fail_compile_with(node, /assign to a reserved variable name: 'facts'/)
+          expect('class a { $facts = {} } include a').to fail_compile_with(node, /assign to a reserved variable name: 'facts'/)
+        end
+
+        it 'should make $facts immutable' do
+          node = node_with_facts('string' => 'value', 'array' => ['string'], 'hash' => { 'a' => 'string' }, 'number' => 1, 'boolean' => true)
+
+          expect('$i=inline_template("<% @facts[%q{new}] = 2 %>")').to fail_compile_with(node, /frozen Hash/i)
+          expect('$i=inline_template("<% @facts[%q{string}].chop! %>")').to fail_compile_with(node, /frozen String/i)
+
+          expect('$i=inline_template("<% @facts[%q{array}][0].chop! %>")').to fail_compile_with(node, /frozen String/i)
+          expect('$i=inline_template("<% @facts[%q{array}][1] = 2 %>")').to fail_compile_with(node, /frozen Array/i)
+
+          expect('$i=inline_template("<% @facts[%q{hash}][%q{a}].chop! %>")').to fail_compile_with(node, /frozen String/i)
+          expect('$i=inline_template("<% @facts[%q{hash}][%q{b}] = 2 %>")').to fail_compile_with(node, /frozen Hash/i)
+        end
+
+        it 'should make $facts available even if there are no facts' do
+          Puppet[:facts_terminus] = :memory
+          node = Puppet::Node.new("testing2")
+          node.fact_merge
+
+          catalog = compile_to_catalog(<<-MANIFEST, node)
+            notify { 'test': message => $facts }
+          MANIFEST
+
+          expect(catalog).to have_resource("Notify[test]").with_parameter(:message, {})
+        end
+      end
+
+      context 'and have not opted in to immutable_node_data' do
+        before :each do
+          Puppet[:immutable_node_data] = false
+        end
+
+        it 'should not make $facts available' do
+         Puppet[:facts_terminus] = :memory
+         facts = Puppet::Node::Facts.new("testing", 'the_facts' => 'straight')
+         Puppet::Node::Facts.indirection.save(facts)
+         node = Puppet::Node.new("testing")
+         node.fact_merge
+
+          catalog = compile_to_catalog(<<-MANIFEST, node)
+            notify { 'test': message => "An $facts space" }
+          MANIFEST
+
+          catalog.resource("Notify[test]")[:message].should == "An  space"
+        end
+      end
+    end
+
     context 'when working with the trusted data hash' do
       context 'and have opted in to trusted_node_data' do
         before :each do
@@ -409,16 +510,4 @@ describe "Puppet::Parser::Compiler" do
     it_behaves_like 'the compiler' do
     end
   end
-
-  describe 'using future parser' do
-    # have absolutely no clue to why this is needed - if not required here (even if required by used classes)
-    # the tests will fail with error that rgen/ecore/ruby_to_ecore cannot be found...
-    # TODO: Solve this mystery !
-    require 'rgen/metamodel_builder'
-
-    before :each do
-      Puppet[:parser] = 'future'
-    end
-    it_behaves_like 'the compiler'
-  end
 end