puppet 6.0.10-universal-darwin → 6.1.0-universal-darwin

data/spec/unit/parser/relationship_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/parser/relationship'

data/spec/unit/parser/resource_spec.rb

@@ -49,24 +49,24 @@ describe Puppet::Parser::Resource do
   end
 
   it "should get its environment from its scope" do
-    scope = double('scope', :source => double("source"))
-    expect(scope).to receive(:environment).and_return("foo").at_least(:once)
-    expect(scope).to receive(:lookupdefaults).and_return({})
+    scope = stub 'scope', :source => stub("source")
+    scope.expects(:environment).returns("foo").at_least_once
+    scope.expects(:lookupdefaults).returns({})
     expect(Puppet::Parser::Resource.new("file", "whatever", :scope => scope).environment).to eq("foo")
   end
 
   it "should use the scope's environment as its environment" do
-    expect(@scope).to receive(:environment).and_return("myenv").at_least(:once)
+    @scope.expects(:environment).returns("myenv").at_least_once
     expect(Puppet::Parser::Resource.new("file", "whatever", :scope => @scope).environment).to eq("myenv")
   end
 
   it "should be isomorphic if it is builtin and models an isomorphic type" do
-    expect(Puppet::Type.type(:file)).to receive(:isomorphic?).and_return(true)
+    Puppet::Type.type(:file).expects(:isomorphic?).returns(true)
     @resource = expect(Puppet::Parser::Resource.new("file", "whatever", :scope => @scope, :source => @source).isomorphic?).to be_truthy
   end
 
   it "should not be isomorphic if it is builtin and models a non-isomorphic type" do
-    expect(Puppet::Type.type(:file)).to receive(:isomorphic?).and_return(false)
+    Puppet::Type.type(:file).expects(:isomorphic?).returns(false)
     @resource = expect(Puppet::Parser::Resource.new("file", "whatever", :scope => @scope, :source => @source).isomorphic?).to be_falsey
   end
 
@@ -81,9 +81,9 @@ describe Puppet::Parser::Resource do
   end
 
   it "should use a Puppet::Resource for converting to a ral resource" do
-    trans = double('resource', :to_ral => "yay")
+    trans = mock 'resource', :to_ral => "yay"
     @resource = mkresource
-    expect(@resource).to receive(:copy_as_resource).and_return(trans)
+    @resource.expects(:copy_as_resource).returns trans
     expect(@resource.to_ral).to eq("yay")
   end
 
@@ -125,8 +125,8 @@ describe Puppet::Parser::Resource do
   describe "when evaluating" do
     before do
       @catalog = Puppet::Resource::Catalog.new
-      source = double('source')
-      allow(source).to receive(:module_name)
+      source = stub('source')
+      source.stubs(:module_name)
       @scope = Puppet::Parser::Scope.new(@compiler, :source => source)
       @catalog.add_resource(Puppet::Parser::Resource.new("stage", :main, :scope => @scope))
     end
@@ -134,7 +134,7 @@ describe Puppet::Parser::Resource do
     it "should evaluate the associated AST definition" do
       definition = newdefine "mydefine"
       res = Puppet::Parser::Resource.new("mydefine", "whatever", :scope => @scope, :source => @source, :catalog => @catalog)
-      expect(definition).to receive(:evaluate_code).with(res)
+      definition.expects(:evaluate_code).with(res)
 
       res.evaluate
     end
@@ -142,14 +142,14 @@ describe Puppet::Parser::Resource do
     it "should evaluate the associated AST class" do
       @class = newclass "myclass"
       res = Puppet::Parser::Resource.new("class", "myclass", :scope => @scope, :source => @source, :catalog => @catalog)
-      expect(@class).to receive(:evaluate_code).with(res)
+      @class.expects(:evaluate_code).with(res)
       res.evaluate
     end
 
     it "should evaluate the associated AST node" do
       nodedef = newnode("mynode")
       res = Puppet::Parser::Resource.new("node", "mynode", :scope => @scope, :source => @source, :catalog => @catalog)
-      expect(nodedef).to receive(:evaluate_code).with(res)
+      nodedef.expects(:evaluate_code).with(res)
       res.evaluate
     end
 
@@ -314,19 +314,19 @@ describe Puppet::Parser::Resource do
     let(:resource) { Puppet::Parser::Resource.new('file', 'whatever', :scope => @scope, :source => @source) }
 
     it 'should add all defaults available from the scope' do
-      expect(@scope).to receive(:lookupdefaults).with('File').and_return(:owner => param(:owner, 'default', @source))
+      @scope.expects(:lookupdefaults).with('File').returns(:owner => param(:owner, 'default', @source))
 
       expect(resource[:owner]).to eq('default')
     end
 
     it 'should not replace existing parameters with defaults' do
-      expect(@scope).to receive(:lookupdefaults).with('File').and_return(:owner => param(:owner, 'replaced', @source))
+      @scope.expects(:lookupdefaults).with('File').returns(:owner => param(:owner, 'replaced', @source))
       r = Puppet::Parser::Resource.new('file', 'whatever', :scope => @scope, :source => @source, :parameters => [ param(:owner, 'oldvalue', @source) ])
       expect(r[:owner]).to eq('oldvalue')
     end
 
     it 'should override defaults with new parameters' do
-      expect(@scope).to receive(:lookupdefaults).with('File').and_return(:owner => param(:owner, 'replaced', @source))
+      @scope.expects(:lookupdefaults).with('File').returns(:owner => param(:owner, 'replaced', @source))
 
       resource.set_parameter(:owner, 'newvalue')
       expect(resource[:owner]).to eq('newvalue')
@@ -336,14 +336,14 @@ describe Puppet::Parser::Resource do
       newparam = param(:owner, 'default', @source)
       other = newparam.dup
       other.value = "other"
-      expect(newparam).to receive(:dup).and_return(other)
-      expect(@scope).to receive(:lookupdefaults).with('File').and_return(:owner => newparam)
+      newparam.expects(:dup).returns(other)
+      @scope.expects(:lookupdefaults).with('File').returns(:owner => newparam)
 
       expect(resource[:owner]).to eq('other')
     end
 
     it "should tag with value of default parameter named 'tag'" do
-      expect(@scope).to receive(:lookupdefaults).with('File').and_return(:tag => param(:tag, 'the_tag', @source))
+      @scope.expects(:lookupdefaults).with('File').returns(:tag => param(:tag, 'the_tag', @source))
 
       expect(resource.tags).to include('the_tag')
     end
@@ -356,7 +356,7 @@ describe Puppet::Parser::Resource do
 
     it "should do nothing if it has already been finished" do
       @resource.finish
-      expect(@resource).not_to receive(:add_scope_tags)
+      @resource.expects(:add_scope_tags).never
       @resource.finish
     end
 
@@ -370,9 +370,9 @@ describe Puppet::Parser::Resource do
 
   describe "when being tagged" do
     before do
-      @scope_resource = double('scope_resource', :tags => %w{srone srtwo})
-      allow(@scope).to receive(:resource).and_return(@scope_resource)
-      @resource = Puppet::Parser::Resource.new("file", "yay", :scope => @scope, :source => double('source'))
+      @scope_resource = stub 'scope_resource', :tags => %w{srone srtwo}
+      @scope.stubs(:resource).returns @scope_resource
+      @resource = Puppet::Parser::Resource.new("file", "yay", :scope => @scope, :source => mock('source'))
     end
 
     it "should get tagged with the resource type" do
@@ -384,19 +384,19 @@ describe Puppet::Parser::Resource do
     end
 
     it "should get tagged with each name in the title if the title is a qualified class name" do
-      resource = Puppet::Parser::Resource.new("file", "one::two", :scope => @scope, :source => double('source'))
+      resource = Puppet::Parser::Resource.new("file", "one::two", :scope => @scope, :source => mock('source'))
       expect(resource.tags).to be_include("one")
       expect(resource.tags).to be_include("two")
     end
 
     it "should get tagged with each name in the type if the type is a qualified class name" do
-      resource = Puppet::Parser::Resource.new("one::two", "whatever", :scope => @scope, :source => double('source'))
+      resource = Puppet::Parser::Resource.new("one::two", "whatever", :scope => @scope, :source => mock('source'))
       expect(resource.tags).to be_include("one")
       expect(resource.tags).to be_include("two")
     end
 
     it "should not get tagged with non-alphanumeric titles" do
-      resource = Puppet::Parser::Resource.new("file", "this is a test", :scope => @scope, :source => double('source'))
+      resource = Puppet::Parser::Resource.new("file", "this is a test", :scope => @scope, :source => mock('source'))
       expect(resource.tags).not_to be_include("this is a test")
     end
 
@@ -426,34 +426,34 @@ describe Puppet::Parser::Resource do
 
     it "should fail when the override was not created by a parent class" do
       @override.source = "source2"
-      expect(@override.source).to receive(:child_of?).with("source1").and_return(false)
+      @override.source.expects(:child_of?).with("source1").returns(false)
       expect { @resource.merge(@override) }.to raise_error(Puppet::ParseError)
     end
 
     it "should succeed when the override was created in the current scope" do
       @resource.source = "source3"
       @override.source = @resource.source
-      expect(@override.source).not_to receive(:child_of?).with("source3")
+      @override.source.expects(:child_of?).with("source3").never
       params = {:a => :b, :c => :d}
-      expect(@override).to receive(:parameters).and_return(params)
-      expect(@resource).to receive(:override_parameter).with(:b)
-      expect(@resource).to receive(:override_parameter).with(:d)
+      @override.expects(:parameters).returns(params)
+      @resource.expects(:override_parameter).with(:b)
+      @resource.expects(:override_parameter).with(:d)
       @resource.merge(@override)
     end
 
     it "should succeed when a parent class created the override" do
       @resource.source = "source3"
       @override.source = "source4"
-      expect(@override.source).to receive(:child_of?).with("source3").and_return(true)
+      @override.source.expects(:child_of?).with("source3").returns(true)
       params = {:a => :b, :c => :d}
-      expect(@override).to receive(:parameters).and_return(params)
-      expect(@resource).to receive(:override_parameter).with(:b)
-      expect(@resource).to receive(:override_parameter).with(:d)
+      @override.expects(:parameters).returns(params)
+      @resource.expects(:override_parameter).with(:b)
+      @resource.expects(:override_parameter).with(:d)
       @resource.merge(@override)
     end
 
     it "should add new parameters when the parameter is not set" do
-      allow(@source).to receive(:child_of?).and_return(true)
+      @source.stubs(:child_of?).returns true
       @override.set_parameter(:testing, "value")
       @resource.merge(@override)
 
@@ -461,7 +461,7 @@ describe Puppet::Parser::Resource do
     end
 
     it "should replace existing parameter values" do
-      allow(@source).to receive(:child_of?).and_return(true)
+      @source.stubs(:child_of?).returns true
       @resource.set_parameter(:testing, "old")
       @override.set_parameter(:testing, "value")
 
@@ -471,7 +471,7 @@ describe Puppet::Parser::Resource do
     end
 
     it "should add values to the parameter when the override was created with the '+>' syntax" do
-      allow(@source).to receive(:child_of?).and_return(true)
+      @source.stubs(:child_of?).returns true
       param = Puppet::Parser::Resource::Param.new(:name => :testing, :value => "testing", :source => @resource.source)
       param.add = true
 
@@ -490,7 +490,7 @@ describe Puppet::Parser::Resource do
       @resource.  set_parameter(:testing, "old_val_1")
       @resource_2.set_parameter(:testing, "old_val_2")
 
-      allow(@source).to receive(:child_of?).and_return(true)
+      @source.stubs(:child_of?).returns true
       param = Puppet::Parser::Resource::Param.new(:name => :testing, :value => "new_val", :source => @resource.source)
       param.add = true
       @override.set_parameter(param)
@@ -503,7 +503,7 @@ describe Puppet::Parser::Resource do
     end
 
     it "should promote tag overrides to real tags" do
-      allow(@source).to receive(:child_of?).and_return(true)
+      @source.stubs(:child_of?).returns true
       param = Puppet::Parser::Resource::Param.new(:name => :tag, :value => "testing", :source => @resource.source)
 
       @override.set_parameter(param)
@@ -516,7 +516,7 @@ describe Puppet::Parser::Resource do
   end
 
   it "should be able to be converted to a normal resource" do
-    @source = double('scope', :name => "myscope")
+    @source = stub 'scope', :name => "myscope"
     @resource = mkresource :source => @source
     expect(@resource).to respond_to(:copy_as_resource)
   end
@@ -634,7 +634,7 @@ describe Puppet::Parser::Resource do
 
   # part of #629 -- the undef keyword.  Make sure 'undef' params get skipped.
   it "should not include 'undef' parameters when converting itself to a hash" do
-    resource = Puppet::Parser::Resource.new "file", "/tmp/testing", :source => double("source"), :scope => @scope
+    resource = Puppet::Parser::Resource.new "file", "/tmp/testing", :source => mock("source"), :scope => @scope
     resource[:owner] = :undef
     resource[:mode] = "755"
     expect(resource.to_hash[:owner]).to be_nil

data/spec/unit/parser/scope_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/compiler'
 require 'puppet_spec/scope'
@@ -70,8 +71,8 @@ describe Puppet::Parser::Scope do
   end
 
   it "should be able to retrieve class scopes by object" do
-    klass = double('ast_class')
-    expect(klass).to receive(:name).and_return("myname")
+    klass = mock 'ast_class'
+    klass.expects(:name).returns("myname")
     @scope.class_set "myname", "myscope"
     expect(@scope.class_scope(klass)).to eq("myscope")
   end
@@ -92,7 +93,7 @@ describe Puppet::Parser::Scope do
 
   it "should get its environment from its compiler" do
     env = Puppet::Node::Environment.create(:testing, [])
-    compiler = double('compiler', :environment => env, :is_a? => true)
+    compiler = stub 'compiler', :environment => env, :is_a? => true
     scope = Puppet::Parser::Scope.new(compiler)
     expect(scope.environment).to equal(env)
   end
@@ -145,7 +146,7 @@ describe Puppet::Parser::Scope do
     it "should extend itself with its environment's Functions module as well as the default" do
       env = Puppet::Node::Environment.create(:myenv, [])
       root = Puppet.lookup(:root_environment)
-      compiler = double('compiler', :environment => env, :is_a? => true)
+      compiler = stub 'compiler', :environment => env, :is_a? => true
 
       scope = Puppet::Parser::Scope.new(compiler)
       expect(scope.singleton_class.ancestors).to be_include(Puppet::Parser::Functions.environment_module(env))
@@ -223,22 +224,22 @@ describe Puppet::Parser::Scope do
     end
 
     it "warns and return nil for non found unqualified variable" do
-      expect(Puppet).to receive(:warn_once)
+      Puppet.expects(:warn_once)
       expect(@scope["santa_clause"]).to be_nil
     end
 
     it "warns once for a non found variable" do
-      expect(Puppet).to receive(:send_log).with(:warning, be_a(String)).once
+      Puppet.expects(:send_log).with(:warning, is_a(String)).once
       expect([@scope["santa_claus"],@scope["santa_claus"]]).to eq([nil, nil])
     end
 
     it "warns and return nil for non found qualified variable" do
-      expect(Puppet).to receive(:warn_once)
+      Puppet.expects(:warn_once)
       expect(@scope["north_pole::santa_clause"]).to be_nil
     end
 
     it "does not warn when a numeric variable is missing - they always exist" do
-      expect(Puppet).not_to receive(:warn_once)
+      Puppet.expects(:warn_once).never
       expect(@scope["1"]).to be_nil
     end
 
@@ -260,13 +261,13 @@ describe Puppet::Parser::Scope do
         catalog = Puppet::Resource::Catalog.new
         catalog.add_resource(Puppet::Parser::Resource.new("stage", :main, :scope => Puppet::Parser::Scope.new(@compiler)))
 
-        Puppet::Parser::Resource.new("class", name, :scope => @scope, :source => double('source'), :catalog => catalog).evaluate
+        Puppet::Parser::Resource.new("class", name, :scope => @scope, :source => mock('source'), :catalog => catalog).evaluate
 
         @scope.class_scope(klass)
       end
 
       it "should be able to look up explicitly fully qualified variables from compiler's top scope" do
-        expect(Puppet).not_to receive(:deprecation_warning)
+        Puppet.expects(:deprecation_warning).never
         other_scope = @scope.compiler.topscope
 
         other_scope["othervar"] = "otherval"
@@ -275,7 +276,7 @@ describe Puppet::Parser::Scope do
       end
 
       it "should be able to look up explicitly fully qualified variables from other scopes" do
-        expect(Puppet).not_to receive(:deprecation_warning)
+        Puppet.expects(:deprecation_warning).never
         other_scope = create_class_scope("other")
 
         other_scope["var"] = "otherval"
@@ -284,7 +285,7 @@ describe Puppet::Parser::Scope do
       end
 
       it "should be able to look up deeply qualified variables" do
-        expect(Puppet).not_to receive(:deprecation_warning)
+        Puppet.expects(:deprecation_warning).never
         other_scope = create_class_scope("other::deep::klass")
 
         other_scope["var"] = "otherval"
@@ -300,12 +301,12 @@ describe Puppet::Parser::Scope do
 
       it "should warn and return nil for qualified variables whose classes have not been evaluated" do
         newclass("other::deep::klass")
-        expect(Puppet).to receive(:warn_once)
+        Puppet.expects(:warn_once)
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
 
       it "should warn and return nil for qualified variables whose classes do not exist" do
-        expect(Puppet).to receive(:warn_once)
+        Puppet.expects(:warn_once)
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
 
@@ -314,7 +315,7 @@ describe Puppet::Parser::Scope do
       end
 
       it "should return nil when asked for a non-string qualified variable from a class that has not been evaluated" do
-        allow(@scope).to receive(:warning)
+        @scope.stubs(:warning)
         newclass("other::deep::klass")
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
@@ -536,10 +537,10 @@ describe Puppet::Parser::Scope do
 
   describe "when setting ephemeral vars from matches" do
     before :each do
-      @match = double('match', :is_a? => true)
-      allow(@match).to receive(:[]).with(0).and_return("this is a string")
-      allow(@match).to receive(:captures).and_return([])
-      allow(@scope).to receive(:setvar)
+      @match = stub 'match', :is_a? => true
+      @match.stubs(:[]).with(0).returns("this is a string")
+      @match.stubs(:captures).returns([])
+      @scope.stubs(:setvar)
     end
 
     it "should accept only MatchData" do
@@ -550,32 +551,27 @@ describe Puppet::Parser::Scope do
 
     it "should set $0 with the full match" do
       # This is an internal impl detail test
-      expect(@scope).to receive(:new_match_scope) do |arg|
-        expect(arg[0]).to eq("this is a string")
-      end
+      @scope.expects(:new_match_scope).with { |*arg| arg[0][0] == "this is a string" }
       @scope.ephemeral_from(@match)
     end
 
     it "should set every capture as ephemeral var" do
       # This is an internal impl detail test
-      allow(@match).to receive(:[]).with(1).and_return(:capture1)
-      allow(@match).to receive(:[]).with(2).and_return(:capture2)
-      expect(@scope).to receive(:new_match_scope) do |arg|
-        expect(arg[1]).to eq(:capture1)
-        expect(arg[2]).to eq(:capture2)
-      end
+      @match.stubs(:[]).with(1).returns(:capture1)
+      @match.stubs(:[]).with(2).returns(:capture2)
+      @scope.expects(:new_match_scope).with { |*arg| arg[0][1] == :capture1 && arg[0][2] == :capture2 }
 
       @scope.ephemeral_from(@match)
     end
 
     it "should shadow previous match variables" do
       # This is an internal impl detail test
-      allow(@match).to receive(:[]).with(1).and_return(:capture1)
-      allow(@match).to receive(:[]).with(2).and_return(:capture2)
+      @match.stubs(:[]).with(1).returns(:capture1)
+      @match.stubs(:[]).with(2).returns(:capture2)
 
-      @match2 = double('match', :is_a? => true)
-      allow(@match2).to receive(:[]).with(1).and_return(:capture2_1)
-      allow(@match2).to receive(:[]).with(2).and_return(nil)
+      @match2 = stub 'match', :is_a? => true
+      @match2.stubs(:[]).with(1).returns(:capture2_1)
+      @match2.stubs(:[]).with(2).returns(nil)
       @scope.ephemeral_from(@match)
       @scope.ephemeral_from(@match2)
       expect(@scope.lookupvar('2')).to eq(nil)
@@ -590,13 +586,13 @@ describe Puppet::Parser::Scope do
 
   describe "when managing defaults" do
     it "should be able to set and lookup defaults" do
-      param = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => double("source"))
+      param = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => stub("source"))
       @scope.define_settings(:mytype, param)
       expect(@scope.lookupdefaults(:mytype)).to eq({:myparam => param})
     end
 
     it "should fail if a default is already defined and a new default is being defined" do
-      param = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => double("source"))
+      param = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => stub("source"))
       @scope.define_settings(:mytype, param)
       expect {
         @scope.define_settings(:mytype, param)
@@ -604,20 +600,20 @@ describe Puppet::Parser::Scope do
     end
 
     it "should return multiple defaults at once" do
-      param1 = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => double("source"))
+      param1 = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => stub("source"))
       @scope.define_settings(:mytype, param1)
-      param2 = Puppet::Parser::Resource::Param.new(:name => :other, :value => "myvalue", :source => double("source"))
+      param2 = Puppet::Parser::Resource::Param.new(:name => :other, :value => "myvalue", :source => stub("source"))
       @scope.define_settings(:mytype, param2)
 
       expect(@scope.lookupdefaults(:mytype)).to eq({:myparam => param1, :other => param2})
     end
 
     it "should look up defaults defined in parent scopes" do
-      param1 = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => double("source"))
+      param1 = Puppet::Parser::Resource::Param.new(:name => :myparam, :value => "myvalue", :source => stub("source"))
       @scope.define_settings(:mytype, param1)
 
       child_scope = @scope.newscope
-      param2 = Puppet::Parser::Resource::Param.new(:name => :other, :value => "myvalue", :source => double("source"))
+      param2 = Puppet::Parser::Resource::Param.new(:name => :other, :value => "myvalue", :source => stub("source"))
       child_scope.define_settings(:mytype, param2)
 
       expect(child_scope.lookupdefaults(:mytype)).to eq({:myparam => param1, :other => param2})