puppet 3.8.7 → 4.0.0.rc1

data/spec/unit/parser/ast/block_expression_spec.rb

@@ -1,7 +1,8 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'puppet/parser/ast/block_expression'
 
-describe Puppet::Parser::AST::BlockExpression do
+describe 'Puppet::Parser::AST::BlockExpression' do
   class StackDepthAST < Puppet::Parser::AST
     attr_reader :call_depth
     def evaluate(*options)
@@ -28,7 +29,7 @@ describe Puppet::Parser::AST::BlockExpression do
   def assert_all_at_same_depth(*probes)
     depth0 = probes[0].call_depth
     probes.drop(1).each do |p|
-      p.call_depth.should == depth0
+      expect(p.call_depth).to eq(depth0)
     end
   end
 

data/spec/unit/parser/ast/leaf_spec.rb

@@ -10,10 +10,6 @@ describe Puppet::Parser::AST::Leaf do
     @leaf = Puppet::Parser::AST::Leaf.new(:value => @value)
   end
 
-  it "should have an evaluate_match method" do
-    Puppet::Parser::AST::Leaf.new(:value => "value").should respond_to(:evaluate_match)
-  end
-
   describe "when converting to string" do
     it "should transform its value to string" do
       value = stub 'value', :is_a? => true
@@ -23,7 +19,7 @@ describe Puppet::Parser::AST::Leaf do
   end
 
   it "should have a match method" do
-    @leaf.should respond_to(:match)
+    expect(@leaf).to respond_to(:match)
   end
 
   it "should delegate match to ==" do
@@ -33,296 +29,6 @@ describe Puppet::Parser::AST::Leaf do
   end
 end
 
-describe Puppet::Parser::AST::FlatString do
-  describe "when converting to string" do
-    it "should transform its value to a quoted string" do
-      Puppet::Parser::AST::FlatString.new(:value => 'ab').to_s.should == "\"ab\""
-    end
-
-    it "should escape embedded double-quotes" do
-      value = Puppet::Parser::AST::FlatString.new(:value => 'hello "friend"')
-      value.to_s.should == "\"hello \\\"friend\\\"\""
-    end
-  end
-end
-
-describe Puppet::Parser::AST::String do
-  describe "when converting to string" do
-    it "should transform its value to a quoted string" do
-      Puppet::Parser::AST::String.new(:value => 'ab').to_s.should == "\"ab\""
-    end
-
-    it "should escape embedded double-quotes" do
-      value = Puppet::Parser::AST::String.new(:value => 'hello "friend"')
-      value.to_s.should == "\"hello \\\"friend\\\"\""
-    end
-
-    it "should return a dup of its value" do
-      value = ""
-      Puppet::Parser::AST::String.new( :value => value ).evaluate(stub('scope')).should_not be_equal(value)
-    end
-  end
-end
-
-describe Puppet::Parser::AST::Concat do
-  describe "when evaluating" do
-    before :each do
-      node     = Puppet::Node.new('localhost')
-      compiler = Puppet::Parser::Compiler.new(node)
-      @scope   = Puppet::Parser::Scope.new(compiler)
-    end
-
-    it "should interpolate variables and concatenate their values" do
-      one = Puppet::Parser::AST::String.new(:value => "one")
-      one.stubs(:evaluate).returns("one ")
-      two = Puppet::Parser::AST::String.new(:value => "two")
-      two.stubs(:evaluate).returns(" two ")
-      three = Puppet::Parser::AST::String.new(:value => "three")
-      three.stubs(:evaluate).returns(" three")
-      var = Puppet::Parser::AST::Variable.new(:value => "myvar")
-      var.stubs(:evaluate).returns("foo")
-      array = Puppet::Parser::AST::Variable.new(:value => "array")
-      array.stubs(:evaluate).returns(["bar","baz"])
-      concat = Puppet::Parser::AST::Concat.new(:value => [one,var,two,array,three])
-
-      concat.evaluate(@scope).should == 'one foo two barbaz three'
-    end
-
-    it "should transform undef variables to empty string" do
-      var = Puppet::Parser::AST::Variable.new(:value => "myvar")
-      var.stubs(:evaluate).returns(:undef)
-      concat = Puppet::Parser::AST::Concat.new(:value => [var])
-
-      concat.evaluate(@scope).should == ''
-    end
-  end
-end
-
-describe Puppet::Parser::AST::Undef do
-  before :each do
-    node     = Puppet::Node.new('localhost')
-    compiler = Puppet::Parser::Compiler.new(node)
-    @scope   = Puppet::Parser::Scope.new(compiler)
-    @undef   = Puppet::Parser::AST::Undef.new(:value => :undef)
-  end
-
-  it "should match undef with undef" do
-    @undef.evaluate_match(:undef, @scope).should be_true
-  end
-
-  it "should not match undef with an empty string" do
-    @undef.evaluate_match("", @scope).should be_true
-  end
-end
-
-describe Puppet::Parser::AST::HashOrArrayAccess do
-  before :each do
-    node     = Puppet::Node.new('localhost')
-    compiler = Puppet::Parser::Compiler.new(node)
-    @scope   = Puppet::Parser::Scope.new(compiler)
-  end
-
-  describe "when evaluating" do
-    it "should evaluate the variable part if necessary" do
-      @scope["a"] = ["b"]
-
-      variable = stub 'variable', :evaluate => "a"
-      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => variable, :key => 0 )
-
-      variable.expects(:safeevaluate).with(@scope).returns("a")
-
-      access.evaluate(@scope).should == "b"
-    end
-
-    it "should evaluate the access key part if necessary" do
-      @scope["a"] = ["b"]
-
-      index = stub 'index', :evaluate => 0
-      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => index )
-
-      index.expects(:safeevaluate).with(@scope).returns(0)
-
-      access.evaluate(@scope).should == "b"
-    end
-
-    it "should be able to return an array member" do
-      @scope["a"] = %w{val1 val2 val3}
-
-      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => 1 )
-
-      access.evaluate(@scope).should == "val2"
-    end
-
-    it "should be able to return an array member when index is a stringified number" do
-      @scope["a"] = %w{val1 val2 val3}
-
-      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "1" )
-
-      access.evaluate(@scope).should == "val2"
-    end
-
-    it "should raise an error when accessing an array with a key" do
-      @scope["a"] = ["val1", "val2", "val3"]
-
-      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "get_me_the_second_element_please" )
-
-      lambda { access.evaluate(@scope) }.should raise_error
-    end
-
-    it "should be able to return :undef for an unknown array index" do
-      @scope["a"] = ["val1", "val2", "val3"]
-
-      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => 6 )
-
-      access.evaluate(@scope).should == :undef
-    end
-
-    it "should be able to return a hash value" do
-      @scope["a"] = { "key1" => "val1", "key2" => "val2", "key3" => "val3" }
-
-      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key2" )
-
-      access.evaluate(@scope).should == "val2"
-    end
-
-    it "should be able to return :undef for unknown hash keys" do
-      @scope["a"] = { "key1" => "val1", "key2" => "val2", "key3" => "val3" }
-
-      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key12" )
-
-      access.evaluate(@scope).should == :undef
-    end
-
-    it "should be able to return a hash value with a numerical key" do
-      @scope["a"] = { "key1" => "val1", "key2" => "val2", "45" => "45", "key3" => "val3" }
-
-      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "45" )
-
-      access.evaluate(@scope).should == "45"
-    end
-
-    it "should raise an error if the variable lookup didn't return a hash or an array" do
-      @scope["a"] = "I'm a string"
-
-      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key2" )
-
-      lambda { access.evaluate(@scope) }.should raise_error
-    end
-
-    it "should raise an error if the variable wasn't in the scope" do
-      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key2" )
-
-      lambda { access.evaluate(@scope) }.should raise_error
-    end
-
-    it "should return a correct string representation" do
-      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key2" )
-      access.to_s.should == '$a[key2]'
-    end
-
-    it "should work with recursive hash access" do
-      @scope["a"] = { "key" => { "subkey" => "b" }}
-
-      access1 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key")
-      access2 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => access1, :key => "subkey")
-
-      access2.evaluate(@scope).should == 'b'
-    end
-
-    it "should work with interleaved array and hash access" do
-      @scope['a'] = { "key" => [ "a" , "b" ]}
-
-      access1 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key")
-      access2 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => access1, :key => 1)
-
-      access2.evaluate(@scope).should == 'b'
-    end
-
-    it "should raise a useful error for hash access on undef" do
-      @scope["a"] = :undef
-
-      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key")
-
-      expect {
-        access.evaluate(@scope)
-      }.to raise_error(Puppet::ParseError, /not a hash or array/)
-    end
-
-    it "should raise a useful error for hash access on TrueClass" do
-      @scope["a"] = true
-
-      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key")
-
-      expect {
-        access.evaluate(@scope)
-      }.to raise_error(Puppet::ParseError, /not a hash or array/)
-    end
-
-    it "should raise a useful error for recursive undef hash access" do
-      @scope["a"] = { "key" => "val" }
-
-      access1 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "nonexistent")
-      access2 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => access1, :key => "subkey")
-
-      expect {
-        access2.evaluate(@scope)
-      }.to raise_error(Puppet::ParseError, /not a hash or array/)
-    end
-
-    it "should produce boolean values when value is a boolean" do
-      @scope["a"] = [true, false]
-      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => 0 )
-      expect(access.evaluate(@scope)).to be == true
-      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => 1 )
-      expect(access.evaluate(@scope)).to be == false
-    end
-  end
-
-  describe "when assigning" do
-    it "should add a new key and value" do
-      Puppet.expects(:warning).once
-      node     = Puppet::Node.new('localhost')
-      compiler = Puppet::Parser::Compiler.new(node)
-      scope    = Puppet::Parser::Scope.new(compiler)
-
-      scope['a'] = { 'a' => 'b' }
-
-      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "b")
-      access.assign(scope, "c" )
-
-      scope['a'].should be_include("b")
-    end
-
-    it "should raise an error when assigning an array element with a key" do
-      @scope['a'] = []
-
-      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "get_me_the_second_element_please" )
-
-      lambda { access.assign(@scope, "test") }.should raise_error
-    end
-
-    it "should be able to return an array member when index is a stringified number" do
-      Puppet.expects(:warning).once
-      node     = Puppet::Node.new('localhost')
-      compiler = Puppet::Parser::Compiler.new(node)
-      scope    = Puppet::Parser::Scope.new(compiler)
-
-      scope['a'] = []
-
-      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "0" )
-
-      access.assign(scope, "val2")
-      scope['a'].should == ["val2"]
-    end
-
-    it "should raise an error when trying to overwrite a hash value" do
-      @scope['a'] = { "key" => [ "a" , "b" ]}
-      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key")
-
-      lambda { access.assign(@scope, "test") }.should raise_error
-    end
-  end
-end
 
 describe Puppet::Parser::AST::Regex do
   before :each do
@@ -350,57 +56,8 @@ describe Puppet::Parser::AST::Regex do
     it "should return self" do
       val = Puppet::Parser::AST::Regex.new :value => "/ab/"
 
-      val.evaluate(@scope).should === val
-    end
-  end
-
-  describe "when evaluate_match" do
-    before :each do
-      @value = stub 'regex'
-      @value.stubs(:match).with("value").returns(true)
-      Regexp.stubs(:new).returns(@value)
-      @regex = Puppet::Parser::AST::Regex.new :value => "/ab/"
-    end
-
-    it "should issue the regexp match" do
-      @value.expects(:match).with("value")
-
-      @regex.evaluate_match("value", @scope)
+      expect(val.evaluate(@scope)).to be === val
     end
-
-    it "should not downcase the paramater value" do
-      @value.expects(:match).with("VaLuE")
-
-      @regex.evaluate_match("VaLuE", @scope)
-    end
-
-    it "should set ephemeral scope vars if there is a match" do
-      @scope.expects(:ephemeral_from).with(true, nil, nil)
-
-      @regex.evaluate_match("value", @scope)
-    end
-
-    it "should return the match to the caller" do
-      @value.stubs(:match).with("value").returns(:match)
-      @scope.stubs(:ephemeral_from)
-
-      @regex.evaluate_match("value", @scope)
-    end
-  end
-
-  it "should match undef to the empty string" do
-    regex = Puppet::Parser::AST::Regex.new(:value => "^$")
-    regex.evaluate_match(:undef, @scope).should be_true
-  end
-
-  it "should not match undef to a non-empty string" do
-    regex = Puppet::Parser::AST::Regex.new(:value => '\w')
-    regex.evaluate_match(:undef, @scope).should be_false
-  end
-
-  it "should match a string against a string" do
-    regex = Puppet::Parser::AST::Regex.new(:value => '\w')
-    regex.evaluate_match('foo', @scope).should be_true
   end
 
   it "should return the regex source with to_s" do
@@ -424,36 +81,6 @@ describe Puppet::Parser::AST::Regex do
   end
 end
 
-describe Puppet::Parser::AST::Variable do
-  before :each do
-    node     = Puppet::Node.new('localhost')
-    compiler = Puppet::Parser::Compiler.new(node)
-    @scope = Puppet::Parser::Scope.new(compiler)
-    @var = Puppet::Parser::AST::Variable.new(:value => "myvar", :file => 'my.pp', :line => 222)
-  end
-
-  it "should lookup the variable in scope" do
-    @scope["myvar"] = :myvalue
-    @var.safeevaluate(@scope).should == :myvalue
-  end
-
-  it "should pass the source location to lookupvar" do
-    @scope.setvar("myvar", :myvalue, :file => 'my.pp', :line => 222 )
-    @var.safeevaluate(@scope).should == :myvalue
-  end
-
-  it "should return undef if the variable wasn't set" do
-    @var.safeevaluate(@scope).should == :undef
-  end
-
-  describe "when converting to string" do
-    it "should transform its value to a variable" do
-      value = stub 'value', :is_a? => true, :to_s => "myvar"
-      Puppet::Parser::AST::Variable.new( :value => value ).to_s.should == "\$myvar"
-    end
-  end
-end
-
 describe Puppet::Parser::AST::HostName do
   before :each do
     node     = Puppet::Node.new('localhost')
@@ -466,11 +93,11 @@ describe Puppet::Parser::AST::HostName do
   end
 
   it "should raise an error if hostname is not valid" do
-    lambda { Puppet::Parser::AST::HostName.new( :value => "not a hostname!" ) }.should raise_error
+    expect { Puppet::Parser::AST::HostName.new( :value => "not a hostname!" ) }.to raise_error
   end
 
   it "should not raise an error if hostname is a regex" do
-    lambda { Puppet::Parser::AST::HostName.new( :value => Puppet::Parser::AST::Regex.new(:value => "/test/") ) }.should_not raise_error
+    expect { Puppet::Parser::AST::HostName.new( :value => Puppet::Parser::AST::Regex.new(:value => "/test/") ) }.not_to raise_error
   end
 
   it "should stringify the value" do
@@ -490,7 +117,7 @@ describe Puppet::Parser::AST::HostName do
   end
 
   it "should evaluate to its value" do
-    @host.evaluate(@scope).should == @value
+    expect(@host.evaluate(@scope)).to eq(@value)
   end
 
   it "should delegate eql? to the underlying value if it is an HostName" do

data/spec/unit/parser/compiler_spec.rb

@@ -59,6 +59,8 @@ describe Puppet::Parser::Compiler do
     Puppet::Parser::Resource.new(type, title, :scope => @scope)
   end
 
+  let(:environment) { Puppet::Node::Environment.create(:testing, []) }
+
   before :each do
     # Push me faster, I wanna go back in time!  (Specifically, freeze time
     # across the test since we have a bunch of version == timestamp code
@@ -67,7 +69,6 @@ describe Puppet::Parser::Compiler do
     now = Time.now
     Time.stubs(:now).returns(now)
 
-    environment = Puppet::Node::Environment.create(:testing, [])
     @node = Puppet::Node.new("testnode",
                              :facts => Puppet::Node::Facts.new("facts", {}),
                              :environment => environment)
@@ -80,22 +81,22 @@ describe Puppet::Parser::Compiler do
 
   it "should fail intelligently when a class-level compile fails" do
     Puppet::Parser::Compiler.expects(:new).raises ArgumentError
-    lambda { Puppet::Parser::Compiler.compile(@node) }.should raise_error(Puppet::Error)
+    expect { Puppet::Parser::Compiler.compile(@node) }.to raise_error(Puppet::Error)
   end
 
   it "should use the node's environment as its environment" do
-    @compiler.environment.should equal(@node.environment)
+    expect(@compiler.environment).to equal(@node.environment)
   end
 
-  it "fails if the node's environment has conflicting manifest settings" do
+  it "fails if the node's environment has validation errors" do
     conflicted_environment = Puppet::Node::Environment.create(:testing, [], '/some/environment.conf/manifest.pp')
-    conflicted_environment.stubs(:conflicting_manifest_settings?).returns(true)
+    conflicted_environment.stubs(:validation_errors).returns(['bad environment'])
     @node.environment = conflicted_environment
-    expect { Puppet::Parser::Compiler.compile(@node) }.to raise_error(Puppet::Error, /disable_per_environment_manifest.*true.*environment.conf.*manifest.*conflict/)
+    expect { Puppet::Parser::Compiler.compile(@node) }.to raise_error(Puppet::Error, /Compilation has been halted because.*bad environment/)
   end
 
   it "should include the resource type collection helper" do
-    Puppet::Parser::Compiler.ancestors.should be_include(Puppet::Resource::TypeCollectionHelper)
+    expect(Puppet::Parser::Compiler.ancestors).to be_include(Puppet::Resource::TypeCollectionHelper)
   end
 
   it "should be able to return a class list containing all added classes" do
@@ -103,25 +104,25 @@ describe Puppet::Parser::Compiler do
     @compiler.add_class "one"
     @compiler.add_class "two"
 
-    @compiler.classlist.sort.should == %w{one two}.sort
+    expect(@compiler.classlist.sort).to eq(%w{one two}.sort)
   end
 
   describe "when initializing" do
 
     it "should set its node attribute" do
-      @compiler.node.should equal(@node)
+      expect(@compiler.node).to equal(@node)
     end
     it "should detect when ast nodes are absent" do
-      @compiler.ast_nodes?.should be_false
+      expect(@compiler.ast_nodes?).to be_falsey
     end
 
     it "should detect when ast nodes are present" do
       @known_resource_types.expects(:nodes?).returns true
-      @compiler.ast_nodes?.should be_true
+      expect(@compiler.ast_nodes?).to be_truthy
     end
 
     it "should copy the known_resource_types version to the catalog" do
-      @compiler.catalog.version.should == @known_resource_types.version
+      expect(@compiler.catalog.version).to eq(@known_resource_types.version)
     end
 
     it "should copy any node classes into the class list" do
@@ -129,7 +130,7 @@ describe Puppet::Parser::Compiler do
       node.classes = %w{foo bar}
       compiler = Puppet::Parser::Compiler.new(node)
 
-      compiler.classlist.should =~ ['foo', 'bar']
+      expect(compiler.classlist).to match_array(['foo', 'bar'])
     end
 
     it "should transform node class hashes into a class list" do
@@ -137,36 +138,36 @@ describe Puppet::Parser::Compiler do
       node.classes = {'foo'=>{'one'=>'p1'}, 'bar'=>{'two'=>'p2'}}
       compiler = Puppet::Parser::Compiler.new(node)
 
-      compiler.classlist.should =~ ['foo', 'bar']
+      expect(compiler.classlist).to match_array(['foo', 'bar'])
     end
 
     it "should add a 'main' stage to the catalog" do
-      @compiler.catalog.resource(:stage, :main).should be_instance_of(Puppet::Parser::Resource)
+      expect(@compiler.catalog.resource(:stage, :main)).to be_instance_of(Puppet::Parser::Resource)
     end
   end
 
   describe "when managing scopes" do
 
     it "should create a top scope" do
-      @compiler.topscope.should be_instance_of(Puppet::Parser::Scope)
+      expect(@compiler.topscope).to be_instance_of(Puppet::Parser::Scope)
     end
 
     it "should be able to create new scopes" do
-      @compiler.newscope(@compiler.topscope).should be_instance_of(Puppet::Parser::Scope)
+      expect(@compiler.newscope(@compiler.topscope)).to be_instance_of(Puppet::Parser::Scope)
     end
 
     it "should set the parent scope of the new scope to be the passed-in parent" do
       scope = mock 'scope'
       newscope = @compiler.newscope(scope)
 
-      newscope.parent.should equal(scope)
+      expect(newscope.parent).to equal(scope)
     end
 
     it "should set the parent scope of the new scope to its topscope if the parent passed in is nil" do
       scope = mock 'scope'
       newscope = @compiler.newscope(nil)
 
-      newscope.parent.should equal(@compiler.topscope)
+      expect(newscope.parent).to equal(@compiler.topscope)
     end
   end
 
@@ -187,8 +188,8 @@ describe Puppet::Parser::Compiler do
       @node.stubs(:parameters).returns(params)
       compile_stub(:set_node_parameters)
       @compiler.compile
-      @compiler.topscope['a'].should == "b"
-      @compiler.topscope['c'].should == "d"
+      expect(@compiler.topscope['a']).to eq("b")
+      expect(@compiler.topscope['c']).to eq("d")
     end
 
     it "should set the client and server versions on the catalog" do
@@ -196,8 +197,8 @@ describe Puppet::Parser::Compiler do
       @node.stubs(:parameters).returns(params)
       compile_stub(:set_node_parameters)
       @compiler.compile
-      @compiler.catalog.client_version.should == "2"
-      @compiler.catalog.server_version.should == "3"
+      expect(@compiler.catalog.client_version).to eq("2")
+      expect(@compiler.catalog.server_version).to eq("3")
     end
 
     it "should evaluate the main class if it exists" do
@@ -212,15 +213,15 @@ describe Puppet::Parser::Compiler do
     it "should create a new, empty 'main' if no main class exists" do
       compile_stub(:evaluate_main)
       @compiler.compile
-      @known_resource_types.find_hostclass([""], "").should be_instance_of(Puppet::Resource::Type)
+      expect(@known_resource_types.find_hostclass("")).to be_instance_of(Puppet::Resource::Type)
     end
 
     it "should add an edge between the main stage and main class" do
       @compiler.compile
-      (stage = @compiler.catalog.resource(:stage, "main")).should be_instance_of(Puppet::Parser::Resource)
-      (klass = @compiler.catalog.resource(:class, "")).should be_instance_of(Puppet::Parser::Resource)
+      expect(stage = @compiler.catalog.resource(:stage, "main")).to be_instance_of(Puppet::Parser::Resource)
+      expect(klass = @compiler.catalog.resource(:class, "")).to be_instance_of(Puppet::Parser::Resource)
 
-      @compiler.catalog.edge?(stage, klass).should be_true
+      expect(@compiler.catalog.edge?(stage, klass)).to be_truthy
     end
 
     it "should evaluate all added collections" do
@@ -328,7 +329,7 @@ describe Puppet::Parser::Compiler do
         resource1 = add_resource("meh", main)
 
         @compiler.send(:finish)
-        resource1[:noop].should be_true
+        expect(resource1[:noop]).to be_truthy
       end
 
       it "should add metaparams recursively" do
@@ -339,7 +340,7 @@ describe Puppet::Parser::Compiler do
         resource2 = add_resource("foo", resource1)
 
         @compiler.send(:finish)
-        resource2[:noop].should be_true
+        expect(resource2[:noop]).to be_truthy
       end
 
       it "should prefer metaparams from immediate parents" do
@@ -352,7 +353,7 @@ describe Puppet::Parser::Compiler do
         resource1[:noop] = false
 
         @compiler.send(:finish)
-        resource2[:noop].should be_false
+        expect(resource2[:noop]).to be_falsey
       end
 
       it "should merge tags downward" do
@@ -364,8 +365,8 @@ describe Puppet::Parser::Compiler do
         resource2 = add_resource("foo", resource1)
 
         @compiler.send(:finish)
-        resource2.tags.should be_include("one")
-        resource2.tags.should be_include("two")
+        expect(resource2.tags).to be_include("one")
+        expect(resource2.tags).to be_include("two")
       end
 
       it "should work if only middle resources have metaparams set" do
@@ -376,7 +377,7 @@ describe Puppet::Parser::Compiler do
         resource2 = add_resource("foo", resource1)
 
         @compiler.send(:finish)
-        resource2[:noop].should be_true
+        expect(resource2[:noop]).to be_truthy
       end
     end
 
@@ -386,14 +387,14 @@ describe Puppet::Parser::Compiler do
       resource2 = resource(:file, "youpi")
       @compiler.add_resource(@scope, resource2)
 
-      @compiler.resources.should == [resource1, resource2]
+      expect(@compiler.resources).to eq([resource1, resource2])
     end
 
     it "should add resources that do not conflict with existing resources" do
       resource = resource(:file, "yay")
       @compiler.add_resource(@scope, resource)
 
-      @compiler.catalog.should be_vertex(resource)
+      expect(@compiler.catalog).to be_vertex(resource)
     end
 
     it "should fail to add resources that conflict with existing resources" do
@@ -402,14 +403,14 @@ describe Puppet::Parser::Compiler do
       file2 = resource(:file, path)
 
       @compiler.add_resource(@scope, file1)
-      lambda { @compiler.add_resource(@scope, file2) }.should raise_error(Puppet::Resource::Catalog::DuplicateResourceError)
+      expect { @compiler.add_resource(@scope, file2) }.to raise_error(Puppet::Resource::Catalog::DuplicateResourceError)
     end
 
     it "should add an edge from the scope resource to the added resource" do
       resource = resource(:file, "yay")
       @compiler.add_resource(@scope, resource)
 
-      @compiler.catalog.should be_edge(@scope.resource, resource)
+      expect(@compiler.catalog).to be_edge(@scope.resource, resource)
     end
 
     it "should not add non-class resources that don't specify a stage to the 'main' stage" do
@@ -417,7 +418,7 @@ describe Puppet::Parser::Compiler do
       resource = resource(:file, "foo")
       @compiler.add_resource(@scope, resource)
 
-      @compiler.catalog.should_not be_edge(main, resource)
+      expect(@compiler.catalog).not_to be_edge(main, resource)
     end
 
     it "should not add any parent-edges to stages" do
@@ -426,7 +427,7 @@ describe Puppet::Parser::Compiler do
 
       @scope.resource = resource(:class, "foo")
 
-      @compiler.catalog.edge?(@scope.resource, stage).should be_false
+      expect(@compiler.catalog.edge?(@scope.resource, stage)).to be_falsey
     end
 
     it "should not attempt to add stages to other stages" do
@@ -437,19 +438,19 @@ describe Puppet::Parser::Compiler do
 
       second_stage[:stage] = "other"
 
-      @compiler.catalog.edge?(other_stage, second_stage).should be_false
+      expect(@compiler.catalog.edge?(other_stage, second_stage)).to be_falsey
     end
 
     it "should have a method for looking up resources" do
       resource = resource(:yay, "foo")
       @compiler.add_resource(@scope, resource)
-      @compiler.findresource("Yay[foo]").should equal(resource)
+      expect(@compiler.findresource("Yay[foo]")).to equal(resource)
     end
 
     it "should be able to look resources up by type and title" do
       resource = resource(:yay, "foo")
       @compiler.add_resource(@scope, resource)
-      @compiler.findresource("Yay", "foo").should equal(resource)
+      expect(@compiler.findresource("Yay", "foo")).to equal(resource)
     end
 
     it "should not evaluate virtual defined resources" do
@@ -482,29 +483,29 @@ describe Puppet::Parser::Compiler do
 
     it "should not fail when there are unevaluated resource collections that do not refer to specific resources" do
       coll = stub 'coll', :evaluate => false
-      coll.expects(:resources).returns(nil)
+      coll.expects(:unresolved_resources).returns(nil)
 
       @compiler.add_collection(coll)
 
-      lambda { @compiler.compile }.should_not raise_error
+      expect { @compiler.compile }.not_to raise_error
     end
 
     it "should fail when there are unevaluated resource collections that refer to a specific resource" do
       coll = stub 'coll', :evaluate => false
-      coll.expects(:resources).returns(:something)
+      coll.expects(:unresolved_resources).returns(:something)
 
       @compiler.add_collection(coll)
 
-      lambda { @compiler.compile }.should raise_error Puppet::ParseError, 'Failed to realize virtual resources something'
+      expect { @compiler.compile }.to raise_error(Puppet::ParseError, 'Failed to realize virtual resources something')
     end
 
     it "should fail when there are unevaluated resource collections that refer to multiple specific resources" do
       coll = stub 'coll', :evaluate => false
-      coll.expects(:resources).returns([:one, :two])
+      coll.expects(:unresolved_resources).returns([:one, :two])
 
       @compiler.add_collection(coll)
 
-      lambda { @compiler.compile }.should raise_error Puppet::ParseError, 'Failed to realize virtual resources one, two'
+      expect { @compiler.compile }.to raise_error(Puppet::ParseError, 'Failed to realize virtual resources one, two')
     end
   end
 
@@ -521,19 +522,19 @@ describe Puppet::Parser::Compiler do
 
     it "should fail if there's no source listed for the scope" do
       scope = stub 'scope', :source => nil
-      proc { @compiler.evaluate_classes(%w{one two}, scope) }.should raise_error(Puppet::DevError)
+      expect { @compiler.evaluate_classes(%w{one two}, scope) }.to raise_error(Puppet::DevError)
     end
 
     it "should raise an error if a class is not found" do
-      @scope.expects(:find_hostclass).with("notfound", {:assume_fqname => false}).returns(nil)
-      lambda{ @compiler.evaluate_classes(%w{notfound}, @scope) }.should raise_error(Puppet::Error, /Could not find class/)
+      @scope.expects(:find_hostclass).with("notfound").returns(nil)
+      expect{ @compiler.evaluate_classes(%w{notfound}, @scope) }.to raise_error(Puppet::Error, /Could not find class/)
     end
 
     it "should raise an error when it can't find class" do
       klasses = {'foo'=>nil}
       @node.classes = klasses
-      @compiler.topscope.expects(:find_hostclass).with('foo', {:assume_fqname => false}).returns(nil)
-      lambda{ @compiler.compile }.should raise_error(Puppet::Error, /Could not find class foo for testnode/)
+      @compiler.topscope.expects(:find_hostclass).with('foo').returns(nil)
+      expect{ @compiler.compile }.to raise_error(Puppet::Error, /Could not find class foo for testnode/)
     end
   end
 
@@ -542,11 +543,20 @@ describe Puppet::Parser::Compiler do
     before do
       Puppet.settings[:data_binding_terminus] = "none"
       @class = stub 'class', :name => "my::class"
-      @scope.stubs(:find_hostclass).with("myclass", {:assume_fqname => false}).returns(@class)
+      @scope.stubs(:find_hostclass).with("myclass").returns(@class)
 
       @resource = stub 'resource', :ref => "Class[myclass]", :type => "file"
     end
 
+    around do |example|
+      Puppet.override(
+        :environments => Puppet::Environments::Static.new(environment),
+        :description => "Static loader for specs"
+      ) do
+        example.run
+      end
+    end
+
     it "should evaluate each class" do
       @compiler.catalog.stubs(:tag)
 
@@ -559,7 +569,7 @@ describe Puppet::Parser::Compiler do
     describe "and the classes are specified as a hash with parameters" do
       before do
         @node.classes = {}
-        @ast_obj = Puppet::Parser::AST::String.new(:value => 'foo')
+        @ast_obj = Puppet::Parser::AST::Leaf.new(:value => 'foo')
       end
 
       # Define the given class with default parameters
@@ -577,32 +587,32 @@ describe Puppet::Parser::Compiler do
         classes = {'foo'=>{}, 'bar::foo'=>{}, 'bar'=>{}}
         classes.each { |c, params| define_class(c, params) }
         compile()
-        classes.each { |name, p| @catalog.classes.should include(name) }
+        classes.each { |name, p| expect(@catalog.classes).to include(name) }
       end
 
       it "should provide default values for parameters that have no values specified" do
         define_class('foo', {})
         compile()
-        @catalog.resource(:class, 'foo')['p1'].should == "foo"
+        expect(@catalog.resource(:class, 'foo')['p1']).to eq("foo")
       end
 
       it "should use any provided values" do
         define_class('foo', {'p1' => 'real_value'})
         compile()
-        @catalog.resource(:class, 'foo')['p1'].should == "real_value"
+        expect(@catalog.resource(:class, 'foo')['p1']).to eq("real_value")
       end
 
       it "should support providing some but not all values" do
         define_class('foo', {'p1' => 'real_value'})
         compile()
-        @catalog.resource(:class, 'Foo')['p1'].should == "real_value"
-        @catalog.resource(:class, 'Foo')['p2'].should == "foo"
+        expect(@catalog.resource(:class, 'Foo')['p1']).to eq("real_value")
+        expect(@catalog.resource(:class, 'Foo')['p2']).to eq("foo")
       end
 
       it "should ensure each node class is in catalog and has appropriate tags" do
         klasses = ['bar::foo']
         @node.classes = klasses
-        ast_obj = Puppet::Parser::AST::String.new(:value => 'foo')
+        ast_obj = Puppet::Parser::AST::Leaf.new(:value => 'foo')
         klasses.each do |name|
           klass = Puppet::Resource::Type.new(:hostclass, name, :arguments => {'p1' => ast_obj, 'p2' => ast_obj})
           @compiler.topscope.known_resource_types.add klass
@@ -610,7 +620,7 @@ describe Puppet::Parser::Compiler do
         catalog = @compiler.compile
 
         r2 = catalog.resources.detect {|r| r.title == 'Bar::Foo' }
-        r2.tags.should == Puppet::Util::TagSet.new(['bar::foo', 'class', 'bar', 'foo'])
+        expect(r2.tags).to eq(Puppet::Util::TagSet.new(['bar::foo', 'class', 'bar', 'foo']))
       end
     end
 
@@ -619,7 +629,7 @@ describe Puppet::Parser::Compiler do
       @node.classes = klass
       klass = Puppet::Resource::Type.new(:hostclass, 'foo', :arguments => {'a' => nil, 'b' => nil})
       @compiler.topscope.known_resource_types.add klass
-      lambda { @compiler.compile }.should raise_error(Puppet::ParseError, "Must pass b to Class[Foo]")
+      expect { @compiler.compile }.to raise_error(Puppet::ParseError, "Must pass b to Class[Foo]")
     end
 
     it "should fail if invalid parameters are passed" do
@@ -627,7 +637,7 @@ describe Puppet::Parser::Compiler do
       @node.classes = klass
       klass = Puppet::Resource::Type.new(:hostclass, 'foo', :arguments => {})
       @compiler.topscope.known_resource_types.add klass
-      lambda { @compiler.compile }.should raise_error(Puppet::ParseError, "Invalid parameter 3 on Class[Foo]")
+      expect { @compiler.compile }.to raise_error(Puppet::ParseError, "Invalid parameter: '3' on Class[Foo]")
     end
 
     it "should ensure class is in catalog without params" do
@@ -635,7 +645,7 @@ describe Puppet::Parser::Compiler do
       foo = Puppet::Resource::Type.new(:hostclass, 'foo')
       @compiler.topscope.known_resource_types.add foo
       catalog = @compiler.compile
-      catalog.classes.should include 'foo'
+      expect(catalog.classes).to include 'foo'
     end
 
     it "should not evaluate the resources created for found classes unless asked" do
@@ -674,7 +684,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(:find_hostclass).with("MyClass").returns(@class)
       @scope.stubs(:class_scope).with(@class).returns(@scope)
       @compiler.expects(:add_resource).never
       @resource.expects(:evaluate).never
@@ -710,7 +720,7 @@ describe Puppet::Parser::Compiler do
     end
 
     it "should fail if the named node cannot be found" do
-      proc { @compiler.send(:evaluate_ast_node) }.should raise_error(Puppet::ParseError)
+      expect { @compiler.send(:evaluate_ast_node) }.to raise_error(Puppet::ParseError)
     end
 
     it "should evaluate the first node class matching the node name" do
@@ -761,7 +771,7 @@ describe Puppet::Parser::Compiler do
 
           catalog = compile_to_catalog(manifest, node)
 
-          catalog.resource('Class', 'Something').should_not be_nil
+          expect(catalog.resource('Class', 'Something')).not_to be_nil
         end
 
         it "should evaluate the class without parameters if it's not already included" do
@@ -769,7 +779,7 @@ describe Puppet::Parser::Compiler do
 
           catalog = compile_to_catalog(manifest, node)
 
-          catalog.resource('Class', 'Something').should_not be_nil
+          expect(catalog.resource('Class', 'Something')).not_to be_nil
         end
       end
 
@@ -791,7 +801,7 @@ describe Puppet::Parser::Compiler do
 
             catalog = compile_to_catalog(manifest, node)
 
-            catalog.resource('Class', 'Something').should_not be_nil
+            expect(catalog.resource('Class', 'Something')).not_to be_nil
           end
 
           it "should evaluate the class if it's not already included" do
@@ -801,7 +811,7 @@ describe Puppet::Parser::Compiler do
 
             catalog = compile_to_catalog(manifest, node)
 
-            catalog.resource('Class', 'Something').should_not be_nil
+            expect(catalog.resource('Class', 'Something')).not_to be_nil
           end
         end
 
@@ -831,7 +841,7 @@ describe Puppet::Parser::Compiler do
             catalog = compile_to_catalog(manifest, node)
 
             resource = catalog.resource('Class', 'Something')
-            resource['configuron'].should == 'defrabulated'
+            expect(resource['configuron']).to eq('defrabulated')
           end
         end
 
@@ -867,7 +877,7 @@ describe Puppet::Parser::Compiler do
     end
 
     it "should be able to store overrides" do
-      lambda { @compiler.add_override(@override) }.should_not raise_error
+      expect { @compiler.add_override(@override) }.not_to raise_error
     end
 
     it "should apply overrides to the appropriate resources" do
@@ -895,7 +905,7 @@ describe Puppet::Parser::Compiler do
     it "should fail if the compile is finished and resource overrides have not been applied" do
       @compiler.add_override(@override)
 
-      lambda { @compiler.compile }.should raise_error Puppet::ParseError, 'Could not find resource(s) File[/foo] for overriding'
+      expect { @compiler.compile }.to raise_error Puppet::ParseError, 'Could not find resource(s) File[/foo] for overriding'
     end
   end
 end