puppet 3.0.2 → 3.1.0.rc1

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

@@ -3,7 +3,7 @@ require 'spec_helper'
 
 require 'puppet/resource/catalog'
 
-describe "Puppet::Resource::Catalog::Queue", :if => Puppet.features.pson? do
+describe "Puppet::Resource::Catalog::Queue" do
   before do
     Puppet::Resource::Catalog.indirection.terminus(:queue)
     @catalog = Puppet::Resource::Catalog.new

data/spec/integration/network/formats_spec.rb

@@ -45,60 +45,47 @@ describe Puppet::Network::FormatHandler.format(:s) do
 end
 
 describe Puppet::Network::FormatHandler.format(:pson) do
-  describe "when pson is absent", :if => (! Puppet.features.pson?) do
-
-    before do
-      @pson = Puppet::Network::FormatHandler.format(:pson)
-    end
-
-    it "should not be suitable" do
-      @pson.should_not be_suitable
-    end
+  before do
+    @pson = Puppet::Network::FormatHandler.format(:pson)
   end
 
-  describe "when pson is available", :if => Puppet.features.pson? do
-    before do
-      @pson = Puppet::Network::FormatHandler.format(:pson)
-    end
-
-    it "should be able to render an instance to pson" do
-      instance = PsonIntTest.new("foo")
-      PsonIntTest.canonical_order(@pson.render(instance)).should == PsonIntTest.canonical_order('{"type":"PsonIntTest","data":["foo"]}' )
-    end
+  it "should be able to render an instance to pson" do
+    instance = PsonIntTest.new("foo")
+    PsonIntTest.canonical_order(@pson.render(instance)).should == PsonIntTest.canonical_order('{"type":"PsonIntTest","data":["foo"]}' )
+  end
 
-    it "should be able to render arrays to pson" do
-      @pson.render([1,2]).should == '[1,2]'
-    end
+  it "should be able to render arrays to pson" do
+    @pson.render([1,2]).should == '[1,2]'
+  end
 
-    it "should be able to render arrays containing hashes to pson" do
-      @pson.render([{"one"=>1},{"two"=>2}]).should == '[{"one":1},{"two":2}]'
-    end
+  it "should be able to render arrays containing hashes to pson" do
+    @pson.render([{"one"=>1},{"two"=>2}]).should == '[{"one":1},{"two":2}]'
+  end
 
-    it "should be able to render multiple instances to pson" do
-      one = PsonIntTest.new("one")
-      two = PsonIntTest.new("two")
+  it "should be able to render multiple instances to pson" do
+    one = PsonIntTest.new("one")
+    two = PsonIntTest.new("two")
 
-      PsonIntTest.canonical_order(@pson.render([one,two])).should == PsonIntTest.canonical_order('[{"type":"PsonIntTest","data":["one"]},{"type":"PsonIntTest","data":["two"]}]')
-    end
+    PsonIntTest.canonical_order(@pson.render([one,two])).should == PsonIntTest.canonical_order('[{"type":"PsonIntTest","data":["one"]},{"type":"PsonIntTest","data":["two"]}]')
+  end
 
-    it "should be able to intern pson into an instance" do
-      @pson.intern(PsonIntTest, '{"type":"PsonIntTest","data":["foo"]}').should == PsonIntTest.new("foo")
-    end
+  it "should be able to intern pson into an instance" do
+    @pson.intern(PsonIntTest, '{"type":"PsonIntTest","data":["foo"]}').should == PsonIntTest.new("foo")
+  end
 
-    it "should be able to intern pson with no class information into an instance" do
-      @pson.intern(PsonIntTest, '["foo"]').should == PsonIntTest.new("foo")
-    end
+  it "should be able to intern pson with no class information into an instance" do
+    @pson.intern(PsonIntTest, '["foo"]').should == PsonIntTest.new("foo")
+  end
 
-    it "should be able to intern multiple instances from pson" do
-      @pson.intern_multiple(PsonIntTest, '[{"type": "PsonIntTest", "data": ["one"]},{"type": "PsonIntTest", "data": ["two"]}]').should == [
-        PsonIntTest.new("one"), PsonIntTest.new("two")
-      ]
-    end
+  it "should be able to intern multiple instances from pson" do
+    @pson.intern_multiple(PsonIntTest, '[{"type": "PsonIntTest", "data": ["one"]},{"type": "PsonIntTest", "data": ["two"]}]').should == [
+      PsonIntTest.new("one"), PsonIntTest.new("two")
+    ]
+  end
 
-    it "should be able to intern multiple instances from pson with no class information" do
-      @pson.intern_multiple(PsonIntTest, '[["one"],["two"]]').should == [
-        PsonIntTest.new("one"), PsonIntTest.new("two")
-      ]
-    end
+  it "should be able to intern multiple instances from pson with no class information" do
+    @pson.intern_multiple(PsonIntTest, '[["one"],["two"]]').should == [
+      PsonIntTest.new("one"), PsonIntTest.new("two")
+    ]
   end
 end

data/spec/integration/parser/collector_spec.rb

@@ -1,37 +1,117 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'puppet_spec/compiler'
 
 require 'puppet/parser/collector'
 
 describe Puppet::Parser::Collector do
-  before do
-    @scope = Puppet::Parser::Scope.new(Puppet::Parser::Compiler.new(Puppet::Node.new("mynode")))
+  include PuppetSpec::Compiler
 
-    @resource = Puppet::Parser::Resource.new("file", "/tmp/testing", :scope => @scope, :source => "fakesource")
-    {:owner => "root", :group => "bin", :mode => "644"}.each do |param, value|
-      @resource[param] = value
-    end
+  def expect_the_message_to_be(expected_messages, code, node = Puppet::Node.new('the node'))
+    catalog = compile_to_catalog(code, node)
+    messages = catalog.resources.find_all { |resource| resource.type == 'Notify' }.
+                                 collect { |notify| notify[:message] }
+    messages.should include(*expected_messages)
+  end
+
+  it "matches on title" do
+    expect_the_message_to_be(["the message"], <<-MANIFEST)
+      @notify { "testing": message => "the message" }
+
+      Notify <| title == "testing" |>
+    MANIFEST
   end
 
-  def query(text)
-    code = "File <| #{text} |>"
-    parser = Puppet::Parser::Parser.new(@scope.compiler)
-    return parser.parse(code).code[0].query
-  end
-
-  {true => [%{title == "/tmp/testing"}, %{(title == "/tmp/testing")}, %{group == bin},
-    %{title == "/tmp/testing" and group == bin}, %{title == bin or group == bin},
-    %{title == "/tmp/testing" or title == bin}, %{title == "/tmp/testing"},
-    %{(title == "/tmp/testing" or title == bin) and group == bin}],
-  false => [%{title == bin}, %{title == bin or (title == bin and group == bin)},
-    %{title != "/tmp/testing"}, %{title != "/tmp/testing" and group != bin}]
-  }.each do |result, ary|
-    ary.each do |string|
-      it "should return '#{result}' when collecting resources with '#{string}'" do
-        str, code = query(string).evaluate @scope
-        code.should be_instance_of(Proc)
-        code.call(@resource).should == result
-      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" }
+
+      Notify <| message == "the message" |>
+    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" }
+
+      Notify <| title == "testing" and message == "the message" |>
+    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" }
+
+      Notify <| title == "testing" or message == "other message" |>
+    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" }
+
+      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 "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
+
+  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" }
+
+        include collector_test
+        class collector_test {
+          Notify <| |> {
+            message => "overridden message"
+          }
+        }
+      MANIFEST
+    end
+
+    it "collects with override when inside a define" 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
   end
 end

data/spec/integration/parser/scope_spec.rb

@@ -4,7 +4,7 @@ require 'puppet_spec/compiler'
 describe "Two step scoping for variables" do
   include PuppetSpec::Compiler
 
-  def expect_the_message_to_be(message, node = Puppet::Node.new('the node')) 
+  def expect_the_message_to_be(message, node = Puppet::Node.new('the node'))
     catalog = compile_to_catalog(yield, node)
     catalog.resource('Notify', 'something')[:message].should == message
   end
@@ -13,6 +13,69 @@ describe "Two step scoping for variables" do
     Puppet.expects(:deprecation_warning).never
   end
 
+  describe "fully qualified variable names" do
+    it "keeps nodescope separate from topscope" do
+      expect_the_message_to_be('topscope') do <<-MANIFEST
+          $c = "topscope"
+          node default {
+            $c = "nodescope"
+            notify { 'something': message => $::c }
+          }
+        MANIFEST
+      end
+    end
+  end
+
+  describe "when colliding class and variable names" do
+    it "finds a topscope variable with the same name as a class" do
+      expect_the_message_to_be('topscope') do <<-MANIFEST
+          $c = "topscope"
+          class c { }
+          node default {
+            include c
+            notify { 'something': message => $c }
+          }
+        MANIFEST
+      end
+    end
+
+    it "finds a node scope variable with the same name as a class" do
+      expect_the_message_to_be('nodescope') do <<-MANIFEST
+          class c { }
+          node default {
+            $c = "nodescope"
+            include c
+            notify { 'something': message => $c }
+          }
+        MANIFEST
+      end
+    end
+
+    it "finds a class variable when the class collides with a nodescope variable" do
+      expect_the_message_to_be('class') do <<-MANIFEST
+          class c { $b = "class" }
+          node default {
+            $c = "nodescope"
+            include c
+            notify { 'something': message => $c::b }
+          }
+        MANIFEST
+      end
+    end
+
+    it "finds a class variable when the class collides with a topscope variable" do
+      expect_the_message_to_be('class') do <<-MANIFEST
+          $c = "topscope"
+          class c { $b = "class" }
+          node default {
+            include c
+            notify { 'something': message => $::c::b }
+          }
+        MANIFEST
+      end
+    end
+  end
+
   describe "when using shadowing and inheritance" do
     it "finds value define in the inherited node" do
       expect_the_message_to_be('parent_msg') do <<-MANIFEST

data/spec/integration/resource/catalog_spec.rb

@@ -2,10 +2,8 @@
 require 'spec_helper'
 
 describe Puppet::Resource::Catalog do
-  describe "when pson is available", :if => Puppet.features.pson? do
-    it "should support pson" do
-      Puppet::Resource::Catalog.supported_formats.should be_include(:pson)
-    end
+  it "should support pson" do
+    Puppet::Resource::Catalog.supported_formats.should be_include(:pson)
   end
 
   describe "when using the indirector" do

data/spec/integration/type/package_spec.rb

@@ -11,7 +11,7 @@ describe Puppet::Type.type(:package), "when choosing a default package provider"
     if Facter.value(:operatingsystem) == 'Solaris' && Puppet::Util::Package.versioncmp(Facter.value(:kernelrelease), '5.11') >= 0
       :pkg
     else
-      {"Ubuntu" => :apt, "Debian" => :apt, "Darwin" => :pkgdmg, "RedHat" => :up2date, "Fedora" => :yum, "FreeBSD" => :ports, "OpenBSD" => :openbsd, "Solaris" => :sun}[os]
+      {"Ubuntu" => :apt, "Debian" => :apt, "Darwin" => :pkgdmg, "RedHat" => :up2date, "Fedora" => :yum, "FreeBSD" => :ports, "OpenBSD" => :openbsd, "Solaris" => :sun, "DragonFly" => :pkgin}[os]
     end
   end
 

data/spec/lib/matchers/catalog.rb

@@ -0,0 +1,50 @@
+RSpec::Matchers.define :be_equivalent_to_catalog do |expected|
+  diffable
+
+  match do |actual|
+    actual.is_a? Puppet::Resource::Catalog and
+    expected.is_a? Puppet::Resource::Catalog and
+    compare_catalogs(actual, expected)
+  end
+
+  failure_message_for_should do |actual|
+    "expected catalog #{actual.inspect} would be equivalent to catalog #{expected.inspect}"
+  end
+
+  failure_message_for_should_not do |actual|
+    "expected catalog #{actual.inspect} would not be equivalent to catalog #{expected.inspect}"
+  end
+
+  description do
+    "be equivalent to catalog #{expected.inspect}"
+  end
+
+  def compare_catalogs(actual, expected)
+    compare_attributes([:name, :environment, :tags, :classes], actual, expected) and
+    compare_resources(actual, expected) and
+    compare_relationships(actual, expected)
+  end
+
+  def compare_attributes(attributes, actual, expected)
+    attributes.all? do |attribute|
+      actual.send(attribute) == expected.send(attribute)
+    end
+  end
+
+  def compare_relationships(actual, expected)
+    actual   = actual.edges.sort_by   { |r| r.to_s }
+    expected = expected.edges.sort_by { |r| r.to_s }
+
+    [:source, :target, :event, :callback].all? do |attribute|
+      actual.map(&attribute) == expected.map(&attribute)
+    end
+  end
+
+  def compare_resources(actual, expected)
+    actual   = actual.resources.sort_by   { |r| r.name }
+    expected = expected.resources.sort_by { |r| r.name }
+
+    actual == expected
+  end
+end
+

data/spec/lib/puppet_spec/compiler.rb

@@ -3,4 +3,15 @@ module PuppetSpec::Compiler
     Puppet[:code] = string
     Puppet::Parser::Compiler.compile(node)
   end
+
+  def compile_ruby_to_catalog(string = nil, node = Puppet::Node.new('foonode'))
+    File.stubs(:read).returns(string)
+    Puppet::Parser::Compiler.compile(node)
+  end
+
+  def prepare_compiler
+    let(:compiler) { Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production')) }
+    let(:scope)    { Puppet::Parser::Scope.new compiler }
+  end
+
 end

data/spec/lib/puppet_spec/dsl.rb

@@ -0,0 +1,29 @@
+module PuppetSpec
+  module DSL
+
+    def prepare_compiler_and_scope_for_evaluation
+      let(:compiler) { Puppet::Parser::Compiler.new Puppet::Node.new("test") }
+      let(:scope)    { Puppet::Parser::Scope.new compiler, :source => "test" }
+    end
+
+    def evaluate_in_context(options = {}, &block)
+      eval_scope = options.fetch :scope, scope
+      Puppet::DSL::Context.new(block, options).evaluate eval_scope, eval_scope.known_resource_types
+    end
+
+    def known_resource_types
+      compiler.known_resource_types
+    end
+
+    def evaluate_in_scope(options = {})
+      eval_scope = options.fetch :scope, scope
+      Puppet::DSL::Parser.add_scope eval_scope
+      Puppet::DSL::Parser.known_resource_types = eval_scope.known_resource_types
+      yield
+    ensure
+      Puppet::DSL::Parser.known_resource_types = nil
+      Puppet::DSL::Parser.remove_scope
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,7 @@
-# NOTE: a lot of the stuff in this file is duplicated in the "puppet_spec_helper" in the project
-#  puppetlabs_spec_helper.  We should probably eat our own dog food and get rid of most of this from here,
-#  and have the puppet core itself use puppetlabs_spec_helper
+# NOTE: a lot of the stuff in this file is duplicated in the
+# "puppet_spec_helper" in the project puppetlabs_spec_helper. We should
+# probably eat our own dog food and get rid of most of this from here, and
+# have the puppet core itself use puppetlabs_spec_helper
 
 dir = File.expand_path(File.dirname(__FILE__))
 $LOAD_PATH.unshift File.join(dir, 'lib')
@@ -47,6 +48,17 @@ end
 RSpec.configure do |config|
   include PuppetSpec::Fixtures
 
+  # Examples or groups can selectively tag themselves as broken.
+  # For example;
+  #
+  # rbv = "#{RUBY_VERSION}-p#{RbConfig::CONFIG['PATCHLEVEL']}"
+  # describe "mostly working", :broken => false unless rbv == "1.9.3-p327" do
+  #  it "parses a valid IP" do
+  #    IPAddr.new("::2:3:4:5:6:7:8")
+  #  end
+  # end
+  config.filter_run_excluding :broken => true
+
   config.mock_with :mocha
 
   tmpdir = Dir.mktmpdir("rspecrun")
@@ -59,6 +71,8 @@ RSpec.configure do |config|
     config.formatters.each { |f| f.instance_variable_set(:@output, $stdout) }
   end
 
+  Puppet::Test::TestHelper.initialize
+
   config.before :all do
     Puppet::Test::TestHelper.before_all_tests()
   end