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

data/spec/integration/faces/documentation_spec.rb

@@ -16,10 +16,6 @@ describe "documentation of faces" do
   # bug in it, triggered in something the user might do.
 
   context "face help messages" do
-    # we need to set a bunk module path here, because without doing so,
-    #  the autoloader will try to use it before it is initialized.
-    Puppet[:modulepath] = "/dev/null"
-
     Puppet::Face.faces.sort.each do |face_name|
       # REVISIT: We should walk all versions of the face here...
       let :help do Puppet::Face[:help, :current] end

data/spec/integration/file_bucket/file_spec.rb

@@ -41,4 +41,25 @@ describe Puppet::FileBucket::File do
       end
     end
   end
+
+  describe "saving binary files" do
+    describe "on Ruby 1.8.7", :if => RUBY_VERSION.match(/^1\.8/) do
+      let(:binary) { "\xD1\xF2\r\n\x81NuSc\x00" }
+
+      it "does not error when the same contents are saved twice" do
+        bucket_file = Puppet::FileBucket::File.new(binary)
+        Puppet::FileBucket::File.indirection.save(bucket_file, bucket_file.name)
+        Puppet::FileBucket::File.indirection.save(bucket_file, bucket_file.name)
+      end
+    end
+    describe "on Ruby 1.9+", :if => RUBY_VERSION.match(/^1\.9|^2/) do
+      let(:binary) { "\xD1\xF2\r\n\x81NuSc\x00".force_encoding(Encoding::ASCII_8BIT) }
+
+      it "does not error when the same contents are saved twice" do
+        bucket_file = Puppet::FileBucket::File.new(binary)
+        Puppet::FileBucket::File.indirection.save(bucket_file, bucket_file.name)
+        Puppet::FileBucket::File.indirection.save(bucket_file, bucket_file.name)
+      end
+    end
+  end
 end

data/spec/integration/indirector/catalog/compiler_spec.rb

@@ -13,8 +13,6 @@ describe Puppet::Resource::Catalog::Compiler do
     @catalog.add_resource(@two = Puppet::Resource.new(:file, "/two"))
   end
 
-  after { Puppet.settings.clear }
-
   it "should remove virtual resources when filtering" do
     @one.virtual = true
     Puppet::Resource::Catalog.indirection.terminus.filter(@catalog).resource_refs.should == [ @two.ref ]

data/spec/integration/indirector/catalog/queue_spec.rb

@@ -17,8 +17,6 @@ describe "Puppet::Resource::Catalog::Queue" do
     Puppet[:trace] = true
   end
 
-  after { Puppet.settings.clear }
-
   it "should render catalogs to pson and publish them via the queue client when catalogs are saved" do
     terminus = Puppet::Resource::Catalog.indirection.terminus(:queue)
 

data/spec/integration/indirector/facts/facter_spec.rb

@@ -13,7 +13,7 @@ describe Puppet::Node::Facts::Facter do
       end
     end
 
-    Facter.stubs(:clear)
+    Facter.stubs(:reset)
 
     cat = compile_to_catalog('notify { $downcase_test: }',
                              Puppet::Node.indirection.find('foo'))

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

@@ -48,9 +48,9 @@ describe Puppet::Indirector::FileContent::FileServer, " when finding files" do
     file = File.join(modpath, "files", "myfile")
     File.open(file, "wb") { |f| f.write "1\r\n" }
 
-    Puppet.settings[:modulepath] = path
+    env = Puppet::Node::Environment.create(:foo, [path])
 
-    result = Puppet::FileServing::Content.indirection.find("modules/mymod/myfile")
+    result = Puppet::FileServing::Content.indirection.find("modules/mymod/myfile", :environment => env)
 
     result.should_not be_nil
     result.should be_instance_of(Puppet::FileServing::Content)

data/spec/integration/node/environment_spec.rb

@@ -80,6 +80,30 @@ describe Puppet::Node::Environment do
     end
   end
 
+  shared_examples_for "the environment's initial import in the future" do |settings|
+    it "a manifest referring to a directory invokes recursive 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('sitedir2')
+
+      # 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 c: 20")
+    end
+  end
+
   describe 'using classic parser' do
     it_behaves_like "the environment's initial import",
       :parser => 'current',
@@ -92,18 +116,10 @@ describe Puppet::Node::Environment do
   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/parser/catalog_spec.rb

@@ -75,6 +75,14 @@ describe "A catalog" do
         expect(resources_in(agent_catalog)).to_not include(*exported_resources)
       end
     end
+  end
+
+  describe 'using classic parser' do
+    before :each do
+      Puppet[:parser] = 'current'
+    end
+    it_behaves_like 'when compiled' do
+    end
 
     it "compiles resource creation from appended array as two separate resources" do
       # moved here from acceptance test "jeff_append_to_array.rb"
@@ -92,14 +100,6 @@ describe "A catalog" do
     end
   end
 
-  describe 'using classic parser' do
-    before :each do
-      Puppet[:parser] = 'current'
-    end
-    it_behaves_like 'when compiled' do
-    end
-  end
-
   describe 'using future parser' do
     before :each do
       Puppet[:parser] = 'future'
@@ -113,9 +113,9 @@ describe "A catalog" do
   end
 
   def master_and_agent_catalogs_for(manifest)
-    master_catalog = Puppet::Resource::Catalog::Compiler.new.filter(compile_to_catalog(manifest))
+    compiler = Puppet::Resource::Catalog::Compiler.new
+    master_catalog = compiler.filter(compile_to_catalog(manifest))
     agent_catalog = Puppet::Resource::Catalog.convert_from(:pson, master_catalog.render(:pson))
-
     [master_catalog, agent_catalog]
   end
 

data/spec/integration/parser/class_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'puppet_spec/language'
+
+describe "Class expressions" do
+  extend PuppetSpec::Language
+
+  before :each do
+    Puppet[:parser] = 'future'
+  end
+
+  produces(
+    "class hi { }"                                       => '!defined(Class[Hi])',
+
+    "class hi { } include hi"                            => 'defined(Class[Hi])',
+    "include(hi) class hi { }"                           => 'defined(Class[Hi])',
+
+    "class hi { } class { hi: }"                         => 'defined(Class[Hi])',
+    "class { hi: } class hi { }"                         => 'defined(Class[Hi])',
+
+    "class bye { } class hi inherits bye { } include hi" => 'defined(Class[Hi]) and defined(Class[Bye])')
+
+  produces(<<-EXAMPLE => 'defined(Notify[foo]) and defined(Notify[bar]) and !defined(Notify[foo::bar])')
+    class bar { notify { 'bar': } }
+    class foo::bar { notify { 'foo::bar': } }
+    class foo inherits bar { notify { 'foo': } }
+
+    include foo
+  EXAMPLE
+
+  produces(<<-EXAMPLE => 'defined(Notify[foo]) and defined(Notify[bar]) and !defined(Notify[foo::bar])')
+    class bar { notify { 'bar': } }
+    class foo::bar { notify { 'foo::bar': } }
+    class foo inherits ::bar { notify { 'foo': } }
+
+    include foo
+  EXAMPLE
+end

data/spec/integration/parser/collector_spec.rb

@@ -14,104 +14,263 @@ describe Puppet::Parser::Collector do
     messages.should include(*expected_messages)
   end
 
-  it "matches on title" do
-    expect_the_message_to_be(["the message"], <<-MANIFEST)
-      @notify { "testing": message => "the message" }
+  shared_examples_for "virtual resource collection" do
+    it "matches everything when no query given" do
+      expect_the_message_to_be(["the other message", "the message"], <<-MANIFEST)
+        @notify { "testing": message => "the message" }
+        @notify { "other": message => "the other message" }
 
-      Notify <| title == "testing" |>
-    MANIFEST
-  end
+        Notify <| |>
+      MANIFEST
+    end
 
-  it "matches on other parameters" do
-    expect_the_message_to_be(["the message"], <<-MANIFEST)
-      @notify { "testing": message => "the message" }
-      @notify { "other testing": message => "the wrong message" }
+    it "matches regular resources " do
+      expect_the_message_to_be(["changed", "changed"], <<-MANIFEST)
+        notify { "testing": message => "the message" }
+        notify { "other": message => "the other message" }
 
-      Notify <| message == "the message" |>
-    MANIFEST
-  end
+        Notify <| |> { message => "changed" }
+      MANIFEST
+    end
 
-  it "allows criteria to be combined with 'and'" do
-    expect_the_message_to_be(["the message"], <<-MANIFEST)
-      @notify { "testing": message => "the message" }
-      @notify { "other": message => "the message" }
+    it "matches on tags" do
+      expect_the_message_to_be(["wanted"], <<-MANIFEST)
+        @notify { "testing": tag => ["one"], message => "wanted" }
+        @notify { "other": tag => ["two"], message => "unwanted" }
 
-      Notify <| title == "testing" and message == "the message" |>
-    MANIFEST
-  end
+        Notify <| tag == one |>
+      MANIFEST
+    end
 
-  it "allows criteria to be combined with 'or'" do
-    expect_the_message_to_be(["the message", "other message"], <<-MANIFEST)
-      @notify { "testing": message => "the message" }
-      @notify { "other": message => "other message" }
-      @notify { "yet another": message => "different message" }
+    it "matches on title" do
+      expect_the_message_to_be(["the message"], <<-MANIFEST)
+        @notify { "testing": message => "the message" }
 
-      Notify <| title == "testing" or message == "other message" |>
-    MANIFEST
-  end
+        Notify <| title == "testing" |>
+      MANIFEST
+    end
 
-  it "allows criteria to be combined with 'or'" do
-    expect_the_message_to_be(["the message", "other message"], <<-MANIFEST)
-      @notify { "testing": message => "the message" }
-      @notify { "other": message => "other message" }
-      @notify { "yet another": message => "different message" }
+    it "matches on other parameters" do
+      expect_the_message_to_be(["the message"], <<-MANIFEST)
+        @notify { "testing": message => "the message" }
+        @notify { "other testing": message => "the wrong message" }
 
-      Notify <| title == "testing" or message == "other message" |>
-    MANIFEST
-  end
+        Notify <| message == "the message" |>
+      MANIFEST
+    end
 
-  it "allows criteria to be grouped with parens" do
-    expect_the_message_to_be(["the message", "different message"], <<-MANIFEST)
-      @notify { "testing":     message => "different message", withpath => true }
-      @notify { "other":       message => "the message" }
-      @notify { "yet another": message => "the message",       withpath => true }
+    it "matches against elements of an array valued parameter" do
+      expect_the_message_to_be([["the", "message"]], <<-MANIFEST)
+        @notify { "testing": message => ["the", "message"] }
+        @notify { "other testing": message => ["not", "here"] }
 
-      Notify <| (title == "testing" or message == "the message") and withpath == true |>
-    MANIFEST
-  end
+        Notify <| message == "message" |>
+      MANIFEST
+    end
 
-  it "does not do anything if nothing matches" do
-    expect_the_message_to_be([], <<-MANIFEST)
-      @notify { "testing": message => "different message" }
+    it "allows criteria to be combined with 'and'" do
+      expect_the_message_to_be(["the message"], <<-MANIFEST)
+        @notify { "testing": message => "the message" }
+        @notify { "other": message => "the message" }
 
-      Notify <| title == "does not exist" |>
-    MANIFEST
-  end
+        Notify <| title == "testing" and message == "the message" |>
+      MANIFEST
+    end
 
-  it "excludes items with inequalities" do
-    expect_the_message_to_be(["good message"], <<-MANIFEST)
-      @notify { "testing": message => "good message" }
-      @notify { "the wrong one": message => "bad message" }
+    it "allows criteria to be combined with 'or'" do
+      expect_the_message_to_be(["the message", "other message"], <<-MANIFEST)
+        @notify { "testing": message => "the message" }
+        @notify { "other": message => "other message" }
+        @notify { "yet another": message => "different message" }
 
-      Notify <| title != "the wrong one" |>
-    MANIFEST
-  end
+        Notify <| title == "testing" or message == "other message" |>
+      MANIFEST
+    end
 
-  context "issue #10963" do
-    it "collects with override when inside a class" do
-      expect_the_message_to_be(["overridden message"], <<-MANIFEST)
-        @notify { "testing": message => "original message" }
+    it "allows criteria to be combined with 'or'" do
+      expect_the_message_to_be(["the message", "other message"], <<-MANIFEST)
+        @notify { "testing": message => "the message" }
+        @notify { "other": message => "other message" }
+        @notify { "yet another": message => "different message" }
 
-        include collector_test
-        class collector_test {
-          Notify <| |> {
-            message => "overridden message"
-          }
-        }
+        Notify <| title == "testing" or message == "other message" |>
+      MANIFEST
+    end
+
+    it "allows criteria to be grouped with parens" do
+      expect_the_message_to_be(["the message", "different message"], <<-MANIFEST)
+        @notify { "testing":     message => "different message", withpath => true }
+        @notify { "other":       message => "the message" }
+        @notify { "yet another": message => "the message",       withpath => true }
+
+        Notify <| (title == "testing" or message == "the message") and withpath == true |>
       MANIFEST
     end
 
-    it "collects with override when inside a define" do
-      expect_the_message_to_be(["overridden message"], <<-MANIFEST)
-        @notify { "testing": message => "original message" }
+    it "does not do anything if nothing matches" do
+      expect_the_message_to_be([], <<-MANIFEST)
+        @notify { "testing": message => "different message" }
+
+        Notify <| title == "does not exist" |>
+      MANIFEST
+    end
+
+    it "excludes items with inequalities" do
+      expect_the_message_to_be(["good message"], <<-MANIFEST)
+        @notify { "testing": message => "good message" }
+        @notify { "the wrong one": message => "bad message" }
+
+        Notify <| title != "the wrong one" |>
+      MANIFEST
+    end
+
+    it "does not exclude resources with unequal arrays" do
+      expect_the_message_to_be(["message", ["not this message", "or this one"]], <<-MANIFEST)
+        @notify { "testing": message => "message" }
+        @notify { "the wrong one": message => ["not this message", "or this one"] }
+
+        Notify <| message != "not this message" |>
+      MANIFEST
+    end
+
+    it "does not exclude tags with inequalities" do
+      expect_the_message_to_be(["wanted message", "the way it works"], <<-MANIFEST)
+        @notify { "testing": tag => ["wanted"], message => "wanted message" }
+        @notify { "other": tag => ["why"], message => "the way it works" }
+
+        Notify <| tag != "why" |>
+      MANIFEST
+    end
+
+    it "does not collect classes" do
+      node = Puppet::Node.new('the node')
+      expect do
+        catalog = compile_to_catalog(<<-MANIFEST, node)
+          class theclass {
+            @notify { "testing": message => "good message" }
+          }
+          Class <|  |>
+        MANIFEST
+      end.to raise_error(/Classes cannot be collected/)
+    end
+
+    context "overrides" do
+      it "modifies an existing array" do
+        expect_the_message_to_be([["original message", "extra message"]], <<-MANIFEST)
+          @notify { "testing": message => ["original message"] }
 
-        collector_test { testing: }
-        define collector_test() {
           Notify <| |> {
-            message => "overridden message"
+            message +> "extra message"
           }
-        }
-      MANIFEST
+        MANIFEST
+      end
+
+      it "converts a scalar to an array" do
+        expect_the_message_to_be([["original message", "extra message"]], <<-MANIFEST)
+          @notify { "testing": message => "original message" }
+
+          Notify <| |> {
+            message +> "extra message"
+          }
+        MANIFEST
+      end
+
+      it "collects with override when inside a class (#10963)" do
+        expect_the_message_to_be(["overridden message"], <<-MANIFEST)
+          @notify { "testing": message => "original message" }
+
+          include collector_test
+          class collector_test {
+            Notify <| |> {
+              message => "overridden message"
+            }
+          }
+        MANIFEST
+      end
+
+      it "collects with override when inside a define (#10963)" do
+        expect_the_message_to_be(["overridden message"], <<-MANIFEST)
+          @notify { "testing": message => "original message" }
+
+          collector_test { testing: }
+          define collector_test() {
+            Notify <| |> {
+              message => "overridden message"
+            }
+          }
+        MANIFEST
+      end
+
+      # Catches regression in implemented behavior, this is not to be taken as this is the wanted behavior
+      # but it has been this way for a long time.
+      it "collects and overrides user defined resources immediately (before queue is evaluated)" do
+        expect_the_message_to_be(["overridden"], <<-MANIFEST)
+          define foo($message) {
+            notify { "testing": message => $message }
+          }
+          foo { test: message => 'given' }
+          Foo <|  |> { message => 'overridden' }
+        MANIFEST
+      end
+
+      # Catches regression in implemented behavior, this is not to be taken as this is the wanted behavior
+      # but it has been this way for a long time.
+      it "collects and overrides user defined resources immediately (virtual resources not queued)" do
+        expect_the_message_to_be(["overridden"], <<-MANIFEST)
+          define foo($message) {
+            @notify { "testing": message => $message }
+          }
+          foo { test: message => 'given' }
+          Notify <| |> # must be collected or the assertion does not find it
+          Foo <|  |> { message => 'overridden' }
+        MANIFEST
+      end
+
+      # Catches regression in implemented behavior, this is not to be taken as this is the wanted behavior
+      # but it has been this way for a long time.
+      # Note difference from none +> case where the override takes effect
+      it "collects and overrides user defined resources with +>" do
+        expect_the_message_to_be([["given", "overridden"]], <<-MANIFEST)
+          define foo($message) {
+            notify { "$name": message => $message }
+          }
+          foo { test: message => ['given'] }
+          Notify <|  |> { message +> ['overridden'] }
+        MANIFEST
+      end
+
+      it "collects and overrides virtual resources multiple times using multiple collects" do
+        expect_the_message_to_be(["overridden2"], <<-MANIFEST)
+          @notify { "testing": message => "original" }
+          Notify <|  |> { message => 'overridden1' }
+          Notify <|  |> { message => 'overridden2' }
+        MANIFEST
+      end
+
+      it "collects and overrides non virtual resources multiple times using multiple collects" do
+        expect_the_message_to_be(["overridden2"], <<-MANIFEST)
+          notify { "testing": message => "original" }
+          Notify <|  |> { message => 'overridden1' }
+          Notify <|  |> { message => 'overridden2' }
+        MANIFEST
+      end
+
     end
   end
+
+  describe "in the current parser" do
+    before :each do
+      Puppet[:parser] = 'current'
+    end
+
+    it_behaves_like "virtual resource collection"
+  end
+
+  describe "in the future parser" do
+    before :each do
+      Puppet[:parser] = 'future'
+    end
+
+    it_behaves_like "virtual resource collection"
+  end
 end