puppet 6.0.10-x64-mingw32 → 6.1.0-x64-mingw32

data/spec/unit/pops/types/type_mismatch_describer_spec.rb

@@ -244,15 +244,6 @@ describe 'the type mismatch describer' do
     expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
       /Class\[Test\]: parameter 'opts' expects size to be 1, got 0/))
   end
-
-  it "treats Optional as Optional[Any]" do
-    code = <<-PUPPET
-      class test(Optional $var=undef) {}
-      class { 'test': var => 'hello' }
-    PUPPET
-    expect { eval_and_collect_notices(code) }.not_to raise_error
-  end
-
 end
 end
 end

data/spec/unit/pops/types/type_parser_spec.rb

@@ -172,39 +172,39 @@ describe TypeParser do
 
   context 'with scope context and loader' do
     let!(:scope) { {} }
-    let(:loader) { double }
+    let(:loader) { mock }
 
     before :each do
-      expect(Adapters::LoaderAdapter).to receive(:loader_for_model_object).and_return(loader)
+      Adapters::LoaderAdapter.expects(:loader_for_model_object).returns loader
     end
 
     it 'interprets anything that is not found by the loader to be a type reference' do
-      expect(loader).to receive(:load).with(:type, 'nonesuch').and_return(nil)
+      loader.expects(:load).with(:type, 'nonesuch').returns nil
       expect(parser.parse('Nonesuch', scope)).to be_the_type(types.type_reference('Nonesuch'))
     end
 
     it 'interprets anything that is found by the loader to be what the loader found' do
-      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
+      loader.expects(:load).with(:type, 'file').returns types.resource('File')
       expect(parser.parse('File', scope)).to be_the_type(types.resource('File'))
     end
 
     it "parses a resource type with title" do
-      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
+      loader.expects(:load).with(:type, 'file').returns types.resource('File')
       expect(parser.parse("File['/tmp/foo']", scope)).to be_the_type(types.resource('file', '/tmp/foo'))
     end
 
     it "parses a resource type using 'Resource[type]' form" do
-      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
+      loader.expects(:load).with(:type, 'file').returns types.resource('File')
       expect(parser.parse("Resource[File]", scope)).to be_the_type(types.resource('file'))
     end
 
     it "parses a resource type with title using 'Resource[type, title]'" do
-      expect(loader).to receive(:load).with(:type, 'file').and_return(nil)
+      loader.expects(:load).with(:type, 'file').returns nil
       expect(parser.parse("Resource[File, '/tmp/foo']", scope)).to be_the_type(types.resource('file', '/tmp/foo'))
     end
 
     it "parses a resource type with title using 'Resource[Type[title]]'" do
-      expect(loader).to receive(:load).with(:type, 'nonesuch').and_return(nil)
+      loader.expects(:load).with(:type, 'nonesuch').returns nil
       expect(parser.parse("Resource[Nonesuch['fife']]", scope)).to be_the_type(types.resource('nonesuch', 'fife'))
     end
   end
@@ -213,27 +213,27 @@ describe TypeParser do
     let(:loader) { Puppet::Pops::Loader::BaseLoader.new(nil, "type_parser_unit_test_loader") }
 
     it 'interprets anything that is not found by the loader to be a type reference' do
-      expect(loader).to receive(:load).with(:type, 'nonesuch').and_return(nil)
+      loader.expects(:load).with(:type, 'nonesuch').returns nil
       expect(parser.parse('Nonesuch', loader)).to be_the_type(types.type_reference('Nonesuch'))
     end
 
     it 'interprets anything that is found by the loader to be what the loader found' do
-      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
+      loader.expects(:load).with(:type, 'file').returns types.resource('File')
       expect(parser.parse('File', loader)).to be_the_type(types.resource('file'))
     end
 
     it "parses a resource type with title" do
-      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
+      loader.expects(:load).with(:type, 'file').returns types.resource('File')
       expect(parser.parse("File['/tmp/foo']", loader)).to be_the_type(types.resource('file', '/tmp/foo'))
     end
 
     it "parses a resource type using 'Resource[type]' form" do
-      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
+      loader.expects(:load).with(:type, 'file').returns types.resource('File')
       expect(parser.parse("Resource[File]", loader)).to be_the_type(types.resource('file'))
     end
 
     it "parses a resource type with title using 'Resource[type, title]'" do
-      expect(loader).to receive(:load).with(:type, 'file').and_return(types.resource('File'))
+      loader.expects(:load).with(:type, 'file').returns types.resource('File')
       expect(parser.parse("Resource[File, '/tmp/foo']", loader)).to be_the_type(types.resource('file', '/tmp/foo'))
     end
   end

data/spec/unit/pops/validator/validator_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
 require 'puppet_spec/pops'
@@ -1011,7 +1012,7 @@ describe "validating 4x" do
       result = '$hg_oais::archivematica::requirements::automation_tools::USER' =~ Puppet::Pops::Patterns::VAR_NAME
       t2 = Time.now.nsec
       expect(result).to be(nil)
-      expect(t2-t).to be < 1000000 # one ms as a check for very slow operation, is in fact at ~< 10 microsecond
+      expect(t2-t).to be < 1000000 # one ms as a check for very slow operation, is in fact at ~< 10 microsecond 
     end
   end
 

data/spec/unit/pops/visitor_spec.rb

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

data/spec/unit/property/boolean_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'puppet/property/boolean'
 
 describe Puppet::Property::Boolean do
-  let (:resource) { double('resource') }
+  let (:resource) { mock('resource') }
   subject { described_class.new(:resource => resource) }
 
   [ true, :true, 'true', :yes, 'yes', 'TrUe', 'yEs' ].each do |arg|

data/spec/unit/property/ensure_spec.rb

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

data/spec/unit/property/keyvalue_spec.rb

@@ -1,7 +1,9 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/property/keyvalue'
 
+
 describe 'Puppet::Property::KeyValue' do 
   let(:klass) { Puppet::Property::KeyValue }
 
@@ -13,7 +15,7 @@ describe 'Puppet::Property::KeyValue' do
     before do
       # Wow that's a messy interface to the resource.
       klass.initvars
-      @resource = double('resource', :[]= => nil, :property => nil)
+      @resource = stub 'resource', :[]= => nil, :property => nil
       @property = klass.new(:resource => @resource)
       klass.log_only_changed_or_new_keys = false
     end
@@ -63,20 +65,20 @@ describe 'Puppet::Property::KeyValue' do
 
     describe "when calling inclusive?" do
       it "should use the membership method to look up on the @resource" do
-        expect(@property).to receive(:membership).and_return(:key_value_membership)
-        expect(@resource).to receive(:[]).with(:key_value_membership)
+        @property.expects(:membership).returns(:key_value_membership)
+        @resource.expects(:[]).with(:key_value_membership)
         @property.inclusive?
       end
 
       it "should return true when @resource[membership] == inclusive" do
-        allow(@property).to receive(:membership).and_return(:key_value_membership)
-        allow(@resource).to receive(:[]).with(:key_value_membership).and_return(:inclusive)
+        @property.stubs(:membership).returns(:key_value_membership)
+        @resource.stubs(:[]).with(:key_value_membership).returns(:inclusive)
         expect(@property.inclusive?).to eq(true)
       end
 
       it "should return false when @resource[membership] != inclusive" do
-        allow(@property).to receive(:membership).and_return(:key_value_membership)
-        allow(@resource).to receive(:[]).with(:key_value_membership).and_return(:minimum)
+        @property.stubs(:membership).returns(:key_value_membership)
+        @resource.stubs(:[]).with(:key_value_membership).returns(:minimum)
         expect(@property.inclusive?).to eq(false)
       end
     end
@@ -87,12 +89,12 @@ describe 'Puppet::Property::KeyValue' do
       end
 
       it "should set every key to nil if inclusive?" do
-        allow(@property).to receive(:inclusive?).and_return(true)
+        @property.stubs(:inclusive?).returns(true)
         expect(@property.process_current_hash({:foo => "bar", :do => "re"})).to eq({ :foo => nil, :do => nil })
       end
 
       it "should return the hash if !inclusive?" do
-        allow(@property).to receive(:inclusive?).and_return(false)
+        @property.stubs(:inclusive?).returns(false)
         expect(@property.process_current_hash({:foo => "bar", :do => "re"})).to eq({:foo => "bar", :do => "re"})
       end
     end
@@ -104,22 +106,22 @@ describe 'Puppet::Property::KeyValue' do
 
       it "should call process_current_hash" do
         @property.should = ["foo=baz", "bar=boo"]
-        allow(@property).to receive(:retrieve).and_return({:do => "re", :mi => "fa" })
-        expect(@property).to receive(:process_current_hash).and_return({})
+        @property.stubs(:retrieve).returns({:do => "re", :mi => "fa" })
+        @property.expects(:process_current_hash).returns({})
         @property.should
       end
 
       it "should return the hashed values of @should and the nilled values of retrieve if inclusive" do
         @property.should = ["foo=baz", "bar=boo"]
-        expect(@property).to receive(:retrieve).and_return({:do => "re", :mi => "fa" })
-        expect(@property).to receive(:inclusive?).and_return(true)
+        @property.expects(:retrieve).returns({:do => "re", :mi => "fa" })
+        @property.expects(:inclusive?).returns(true)
         expect(@property.should).to eq({ :foo => "baz", :bar => "boo", :do => nil, :mi => nil })
       end
 
       it "should return the hashed @should + the unique values of retrieve if !inclusive" do
         @property.should = ["foo=baz", "bar=boo"]
-        expect(@property).to receive(:retrieve).and_return({:foo => "diff", :do => "re", :mi => "fa"})
-        expect(@property).to receive(:inclusive?).and_return(false)
+        @property.expects(:retrieve).returns({:foo => "diff", :do => "re", :mi => "fa"})
+        @property.expects(:inclusive?).returns(false)
         expect(@property.should).to eq({ :foo => "baz", :bar => "boo", :do => "re", :mi => "fa" })
       end
 
@@ -130,14 +132,14 @@ describe 'Puppet::Property::KeyValue' do
           :key3 => "new_value3",
           :key4 => "value4"
         }
-        allow(@property).to receive(:retrieve).and_return(
+        @property.stubs(:retrieve).returns(
           {
             :key1 => "value1",
             :key2 => "value2",
             :key3 => "value3"
           }
         )
-        allow(@property).to receive(:inclusive?).and_return(false)
+        @property.stubs(:inclusive?).returns(false)
 
         @property.should
         expect(@property.instance_variable_get(:@changed_or_new_keys)).to eql([:key1, :key3, :key4])
@@ -146,25 +148,25 @@ describe 'Puppet::Property::KeyValue' do
 
     describe "when calling retrieve" do
       before do
-        @provider = double("provider")
-        allow(@property).to receive(:provider).and_return(@provider)
+        @provider = mock("provider")
+        @property.stubs(:provider).returns(@provider)
       end
 
       it "should send 'name' to the provider" do
-        expect(@provider).to receive(:send).with(:keys)
-        expect(@property).to receive(:name).and_return(:keys)
+        @provider.expects(:send).with(:keys)
+        @property.expects(:name).returns(:keys)
         @property.retrieve
       end
 
       it "should return a hash with the provider returned info" do
-        allow(@provider).to receive(:send).with(:keys).and_return({"do" => "re", "mi" => "fa" })
-        allow(@property).to receive(:name).and_return(:keys)
+        @provider.stubs(:send).with(:keys).returns({"do" => "re", "mi" => "fa" })
+        @property.stubs(:name).returns(:keys)
         @property.retrieve == {"do" => "re", "mi" => "fa" }
       end
 
       it "should return :absent when the provider returns :absent" do
-        allow(@provider).to receive(:send).with(:keys).and_return(:absent)
-        allow(@property).to receive(:name).and_return(:keys)
+        @provider.stubs(:send).with(:keys).returns(:absent)
+        @property.stubs(:name).returns(:keys)
         @property.retrieve == :absent
       end
     end
@@ -183,9 +185,9 @@ describe 'Puppet::Property::KeyValue' do
 
     describe "when calling safe_insync?" do
       before do
-        @provider = double("provider")
-        allow(@property).to receive(:provider).and_return(@provider)
-        allow(@property).to receive(:name).and_return(:prop_name)
+        @provider = mock("provider")
+        @property.stubs(:provider).returns(@provider)
+        @property.stubs(:name).returns(:prop_name)
       end
 
       it "should return true unless @should is defined and not nil" do
@@ -197,16 +199,16 @@ describe 'Puppet::Property::KeyValue' do
       end
 
       it "should return true if hashified should value == (retrieved) value passed in" do
-        allow(@provider).to receive(:prop_name).and_return({ :foo => "baz", :bar => "boo" })
+        @provider.stubs(:prop_name).returns({ :foo => "baz", :bar => "boo" })
         @property.should = ["foo=baz", "bar=boo"]
-        expect(@property).to receive(:inclusive?).and_return(true)
+        @property.expects(:inclusive?).returns(true)
         expect(@property.safe_insync?({ :foo => "baz", :bar => "boo" })).to eq(true)
       end
 
       it "should return false if prepared value != should value" do
-        allow(@provider).to receive(:prop_name).and_return({ "foo" => "bee", "bar" => "boo" })
+        @provider.stubs(:prop_name).returns({ "foo" => "bee", "bar" => "boo" })
         @property.should = ["foo=baz", "bar=boo"]
-        expect(@property).to receive(:inclusive?).and_return(true)
+        @property.expects(:inclusive?).returns(true)
         expect(@property.safe_insync?({ "foo" => "bee", "bar" => "boo" })).to eq(false)
       end
     end

data/spec/unit/property/list_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/property/list'
@@ -14,7 +15,7 @@ describe list_class do
     before do
       # Wow that's a messy interface to the resource.
       list_class.initvars
-      @resource = double('resource', :[]= => nil, :property => nil)
+      @resource = stub 'resource', :[]= => nil, :property => nil
       @property = list_class.new(:resource => @resource)
     end
 
@@ -54,20 +55,20 @@ describe list_class do
 
     describe "when calling inclusive?" do
       it "should use the membership method to look up on the @resource" do
-        expect(@property).to receive(:membership).and_return(:membership)
-        expect(@resource).to receive(:[]).with(:membership)
+        @property.expects(:membership).returns(:membership)
+        @resource.expects(:[]).with(:membership)
         @property.inclusive?
       end
 
       it "should return true when @resource[membership] == inclusive" do
-        allow(@property).to receive(:membership).and_return(:membership)
-        allow(@resource).to receive(:[]).with(:membership).and_return(:inclusive)
+        @property.stubs(:membership).returns(:membership)
+        @resource.stubs(:[]).with(:membership).returns(:inclusive)
         expect(@property.inclusive?).to eq(true)
       end
 
       it "should return false when @resource[membership] != inclusive" do
-        allow(@property).to receive(:membership).and_return(:membership)
-        allow(@resource).to receive(:[]).with(:membership).and_return(:minimum)
+        @property.stubs(:membership).returns(:membership)
+        @resource.stubs(:[]).with(:membership).returns(:minimum)
         expect(@property.inclusive?).to eq(false)
       end
     end
@@ -79,14 +80,14 @@ describe list_class do
 
       it "should return the sorted values of @should as a string if inclusive" do
         @property.should = ["foo", "bar"]
-        expect(@property).to receive(:inclusive?).and_return(true)
+        @property.expects(:inclusive?).returns(true)
         expect(@property.should).to eq("bar,foo")
       end
 
       it "should return the uniq sorted values of @should + retrieve as a string if !inclusive" do
         @property.should = ["foo", "bar"]
-        expect(@property).to receive(:inclusive?).and_return(false)
-        expect(@property).to receive(:retrieve).and_return(["foo","baz"])
+        @property.expects(:inclusive?).returns(false)
+        @property.expects(:retrieve).returns(["foo","baz"])
         expect(@property.should).to eq("bar,baz,foo")
       end
     end
@@ -94,25 +95,25 @@ describe list_class do
     describe "when calling retrieve" do
       let(:provider) { @provider }
       before do
-        @provider = double("provider")
-        allow(@property).to receive(:provider).and_return(provider)
+        @provider = mock("provider")
+        @property.stubs(:provider).returns(provider)
       end
 
       it "should send 'name' to the provider" do
-        expect(@provider).to receive(:send).with(:group)
-        expect(@property).to receive(:name).and_return(:group)
+        @provider.expects(:send).with(:group)
+        @property.expects(:name).returns(:group)
         @property.retrieve
       end
 
       it "should return an array with the provider returned info" do
-        allow(@provider).to receive(:send).with(:group).and_return("foo,bar,baz")
-        allow(@property).to receive(:name).and_return(:group)
+        @provider.stubs(:send).with(:group).returns("foo,bar,baz")
+        @property.stubs(:name).returns(:group)
         @property.retrieve == ["foo", "bar", "baz"]
       end
 
       it "should return :absent when the provider returns :absent" do
-        allow(@provider).to receive(:send).with(:group).and_return(:absent)
-        allow(@property).to receive(:name).and_return(:group)
+        @provider.stubs(:send).with(:group).returns(:absent)
+        @property.stubs(:name).returns(:group)
         @property.retrieve == :absent
       end
 
@@ -136,35 +137,35 @@ describe list_class do
 
       it "should call prepare_is_for_comparison with value passed in and should" do
         @property.should = "foo"
-        expect(@property).to receive(:prepare_is_for_comparison).with("bar")
-        expect(@property).to receive(:should)
+        @property.expects(:prepare_is_for_comparison).with("bar")
+        @property.expects(:should)
         @property.safe_insync?("bar")
       end
 
       it "should return true if 'is' value is array of comma delimited should values" do
         @property.should = "bar,foo"
-        expect(@property).to receive(:inclusive?).and_return(true)
+        @property.expects(:inclusive?).returns(true)
         expect(@property).to be_safe_insync(["bar","foo"])
       end
 
       it "should return true if 'is' value is :absent and should value is empty string" do
         @property.should = ""
-        expect(@property).to receive(:inclusive?).and_return(true)
+        @property.expects(:inclusive?).returns(true)
         expect(@property).to be_safe_insync([])
       end
 
       it "should return false if prepared value != should value" do
         @property.should = "bar,baz,foo"
-        expect(@property).to receive(:inclusive?).and_return(true)
+        @property.expects(:inclusive?).returns(true)
         expect(@property).to_not be_safe_insync(["bar","foo"])
       end
     end
 
     describe "when calling dearrayify" do
       it "should sort and join the array with 'delimiter'" do
-        array = double("array")
-        expect(array).to receive(:sort).and_return(array)
-        expect(array).to receive(:join).with(@property.delimiter)
+        array = mock "array"
+        array.expects(:sort).returns(array)
+        array.expects(:join).with(@property.delimiter)
         @property.dearrayify(array)
       end
     end

data/spec/unit/property/ordered_list_spec.rb

@@ -1,18 +1,22 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/property/ordered_list'
 
-describe Puppet::Property::OrderedList do
+ordered_list_class = Puppet::Property::OrderedList
+
+describe ordered_list_class do
+
   it "should be a subclass of List" do
-    expect(described_class.superclass).to eq(Puppet::Property::List)
+    expect(ordered_list_class.superclass).to eq(Puppet::Property::List)
   end
 
   describe "as an instance" do
     before do
       # Wow that's a messy interface to the resource.
-      described_class.initvars
-      @resource = double('resource', :[]= => nil, :property => nil)
-      @property = described_class.new(:resource => @resource)
+      ordered_list_class.initvars
+      @resource = stub 'resource', :[]= => nil, :property => nil
+      @property = ordered_list_class.new(:resource => @resource)
     end
 
     describe "when adding should to current" do
@@ -36,22 +40,22 @@ describe Puppet::Property::OrderedList do
 
       it "should return the values of @should (without sorting) as a string if inclusive" do
         @property.should = ["foo", "bar"]
-        expect(@property).to receive(:inclusive?).and_return(true)
+        @property.expects(:inclusive?).returns(true)
         expect(@property.should).to eq("foo,bar")
       end
 
       it "should return the uniq values of @should + retrieve as a string if !inclusive with the @ values leading" do
         @property.should = ["foo", "bar"]
-        expect(@property).to receive(:inclusive?).and_return(false)
-        expect(@property).to receive(:retrieve).and_return(["foo","baz"])
+        @property.expects(:inclusive?).returns(false)
+        @property.expects(:retrieve).returns(["foo","baz"])
         expect(@property.should).to eq("foo,bar,baz")
       end
     end
 
     describe "when calling dearrayify" do
       it "should join the array with the delimiter" do
-        array = double("array")
-        expect(array).to receive(:join).with(@property.delimiter)
+        array = mock "array"
+        array.expects(:join).with(@property.delimiter)
         @property.dearrayify(array)
       end
     end