puppet 5.3.4 → 6.29.0

data/spec/unit/pops/serialization/serialization_spec.rb

@@ -16,10 +16,12 @@ module Serialization
   let(:serializer) { Serializer.new(writer_class.new(io)) }
   let(:deserializer) { Deserializer.new(reader_class.new(io), loaders.find_loader(nil)) }
 
-  around :each do |example|
-     Puppet.override(:loaders => loaders, :current_environment => env) do
-      example.run
-    end
+  before(:each) do
+    Puppet.push_context(:loaders => loaders, :current_environment => env)
+  end
+
+  after(:each) do
+    Puppet.pop_context()
   end
 
   def write(*values)
@@ -145,6 +147,14 @@ module Serialization
       expect(val2).to eql(val)
     end
 
+    it 'URI' do
+      val = URI('http://bob:ewing@dallas.example.com:8080/oil/baron?crude=cash#leftovers')
+      write(val)
+      val2 = read
+      expect(val2).to be_a(URI)
+      expect(val2).to eql(val)
+    end
+
     it 'Sensitive with rich data' do
       sval = Time::Timestamp.now
       val = Types::PSensitiveType::Sensitive.new(sval)
@@ -225,6 +235,28 @@ module Serialization
         expect(val2).to be_a(Types::PObjectType)
         expect(val2).to eql(val)
       end
+
+      context 'ObjectType' do
+        let(:type) do
+          Types::PObjectType.new({
+            'name' => 'MyType',
+            'type_parameters' => {
+              'x' => Types::PIntegerType::DEFAULT
+            },
+            'attributes' => {
+              'x' => Types::PIntegerType::DEFAULT
+            }
+          })
+        end
+
+        it 'with preserved parameters' do
+          val = type.create(34)._pcore_type
+          write(val)
+          val2 = read
+          expect(val2).to be_a(Types::PObjectTypeExtension)
+          expect(val2).to eql(val)
+        end
+      end
     end
 
     it 'Array of rich data' do
@@ -392,7 +424,7 @@ module Serialization
     it 'succeeds when deserializer is aware of the referenced type' do
       obj = type.create(32)
       write(obj)
-      loaders.find_loader(nil).expects(:load).with(:type, 'mytype').returns(type)
+      expect(loaders.find_loader(nil)).to receive(:load).with(:type, 'mytype').and_return(type)
       expect(read).to eql(obj)
     end
   end

data/spec/unit/pops/serialization/to_from_hr_spec.rb

@@ -30,6 +30,13 @@ module Serialization
     io.rewind
   end
 
+  def write_raw(value)
+    io.reopen
+    expect(Types::TypeFactory.data).to be_instance(value)
+    io << [value].to_json
+    io.rewind
+  end
+
   def read
     from_converter.convert(::JSON.parse(io.read)[0])
   end
@@ -146,6 +153,23 @@ module Serialization
       expect(val2).to eql(val)
     end
 
+    it 'ACII_8BIT String as Binary' do
+      val = Types::PBinaryType::Binary.from_base64('w5ZzdGVuIG1lZCByw7ZzdGVuCg==')
+      strval = val.binary_buffer
+      write(strval)
+      val2 = read
+      expect(val2).to be_a(Types::PBinaryType::Binary)
+      expect(val2).to eql(val)
+    end
+
+    it 'URI' do
+      val = URI('http://bob:ewing@dallas.example.com:8080/oil/baron?crude=cash#leftovers')
+      write(val)
+      val2 = read
+      expect(val2).to be_a(URI)
+      expect(val2).to eql(val)
+    end
+
     it 'Sensitive with rich data' do
       sval = Time::Timestamp.now
       val = Types::PSensitiveType::Sensitive.new(sval)
@@ -251,6 +275,34 @@ module Serialization
         expect(val2).to be_a(Types::PObjectType)
         expect(val2).to eql(val)
       end
+
+      context 'ObjectType' do
+        let(:type) do
+          Types::PObjectType.new({
+            'name' => 'MyType',
+            'type_parameters' => {
+              'x' => Types::PIntegerType::DEFAULT
+            },
+            'attributes' => {
+              'x' => Types::PIntegerType::DEFAULT
+            }
+          })
+        end
+
+        it 'with preserved parameters' do
+          val = type.create(34)._pcore_type
+          write(val)
+          val2 = read
+          expect(val2).to be_a(Types::PObjectTypeExtension)
+          expect(val2).to eql(val)
+        end
+
+        it 'with POjbectTypeExtension type being converted' do
+          val = { 'ObjectExtension' => type.create(34) }
+          expect(to_converter.convert(val))
+            .to eq({"ObjectExtension"=>{"__ptype"=>"MyType", "x"=>34}})
+        end
+      end
     end
 
     it 'Array of rich data' do
@@ -416,11 +468,18 @@ module Serialization
         expect{ read }.to raise_error(Puppet::Error, 'No implementation mapping found for Puppet Type MyType')
       end
 
-      context "succeds but produces an rich_type hash when deserializer has 'allow_unresolved' set to true" do
+      it 'succeeds and produces a hash when a read __ptype key is something other than a string or a hash' do
+        # i.e. this is for content that is not produced by ToDataHash - writing on-the-wire-format directly
+        # to test that it does not crash.
+        write_raw({'__ptype' => 10, 'x'=> 32})
+        expect(read).to eql({'__ptype'=>10, 'x'=>32})
+      end
+
+      context "succeeds but produces an rich_type hash when deserializer has 'allow_unresolved' set to true" do
         let(:from_converter) { FromDataConverter.new(:allow_unresolved => true) }
         it do
           write(type.create(32))
-          expect(read).to eql({'__pcore_type__'=>'MyType', 'x'=>32})
+          expect(read).to eql({'__ptype'=>'MyType', 'x'=>32})
         end
       end
     end
@@ -428,7 +487,7 @@ module Serialization
     it 'succeeds when deserializer is aware of the referenced type' do
       obj = type.create(32)
       write(obj)
-      loaders.find_loader(nil).expects(:load).with(:type, 'mytype').returns(type)
+      expect(loaders.find_loader(nil)).to receive(:load).with(:type, 'mytype').and_return(type)
       expect(read).to eql(obj)
     end
   end
@@ -532,6 +591,17 @@ module Serialization
         expect(warnings).to be_empty
       end
 
+      it 'A Hash with __ptype, __pvalue keys will not be taken as a pcore meta tag' do
+        val = { '__ptype' => 42, '__pvalue' => 43  }
+        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+          write(val)
+          val2 = read
+          expect(val2).to be_a(Hash)
+          expect(val2).to eql({ '__ptype' => 42, '__pvalue' => 43 })
+        end
+        expect(warnings).to be_empty
+      end
+
       it 'A Hash with default values will not loose type information' do
         val = { 'key' => :default  }
         Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
@@ -558,7 +628,7 @@ module Serialization
   context 'will fail when' do
     it 'the value of a type description is something other than a String or a Hash' do
       expect do
-        from_converter.convert({ '__pcore_type__' => { '__pcore_type__' => 'Pcore::TimestampType', '__pcore_value__' => 12345 }})
+        from_converter.convert({ '__ptype' => { '__ptype' => 'Pcore::TimestampType', '__pvalue' => 12345 }})
       end.to raise_error(/Cannot create a Pcore::TimestampType from a (Fixnum|Integer)/)
     end
   end

data/spec/unit/pops/serialization/to_stringified_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+require 'puppet_spec/compiler'
+
+describe 'ToStringifiedConverter' do
+  include PuppetSpec::Compiler
+
+  after(:all) { Puppet::Pops::Loaders.clear }
+
+  let(:env) { Puppet::Node::Environment.create(:testing, []) }
+  let(:loaders) { Puppet::Pops::Loaders.new(env) }
+  let(:node) { Puppet::Node.new(env, environment: env) }
+
+  def transform(v)
+    Puppet::Pops::Serialization::ToStringifiedConverter.convert(v)
+  end
+
+  def eval_transform(source)
+    Puppet.override(:current_environment => env, :loaders => loaders) do
+      transform(evaluate(source: source, node: node))
+    end
+  end
+
+  it 'converts undef to to nil' do
+    expect(transform(nil)).to be_nil
+    expect(eval_transform('undef')).to be_nil
+  end
+
+  it "converts literal default to the string 'default'" do
+    expect(transform(:default)).to eq('default')
+    expect(eval_transform('default')).to eq('default')
+  end
+
+  it "does not convert an integer" do
+    expect(transform(42)).to eq(42)
+  end
+
+  it "does not convert a float" do
+    expect(transform(3.14)).to eq(3.14)
+  end
+
+  it "does not convert a boolean" do
+    expect(transform(true)).to be(true)
+    expect(transform(false)).to be(false)
+  end
+
+  it "does not convert a string (that is free from encoding issues)" do
+    expect(transform("hello")).to eq("hello")
+  end
+
+  it "converts a regexp to a string" do
+    expect(transform(/this|that.*/)).to eq("/this|that.*/")
+    expect(eval_transform('/this|that.*/')).to eq("/this|that.*/")
+  end
+
+  it 'handles a string with an embedded single quote' do
+    expect(transform("ta'phoenix")).to eq("ta'phoenix")
+  end
+
+  it 'handles a string with embedded double quotes' do
+    expect(transform('he said "hi"')).to eq("he said \"hi\"")
+  end
+
+  it 'converts a user defined object to its string representation including attributes' do
+    result = evaluate(code: "type Car = Object[attributes=>{regnbr => String}]", source: "Car(abc123)")
+    expect(transform(result)).to eq("Car({'regnbr' => 'abc123'})")
+  end
+
+  it 'converts a Deferred object to its string representation including attributes' do
+    expect(eval_transform("Deferred(func, [1,2,3])")).to eq("Deferred({'name' => 'func', 'arguments' => [1, 2, 3]})")
+  end
+
+  it 'converts a Sensitive to type + redacted plus id' do
+    sensitive = evaluate(source: "Sensitive('hush')")
+    id = sensitive.object_id
+    expect(transform(sensitive)).to eq("#<Sensitive [value redacted]:#{id}>")
+  end
+
+  it 'converts a Timestamp to String' do
+    expect(eval_transform("Timestamp('2018-09-03T19:45:33.697066000 UTC')")).to eq("2018-09-03T19:45:33.697066000 UTC")
+  end
+
+  it 'does not convert an array' do
+    expect(transform([1,2,3])).to eq([1,2,3])
+  end
+
+  it 'converts the content of an array - for example a Sensitive value' do
+    sensitive = evaluate(source: "Sensitive('hush')")
+    id = sensitive.object_id
+    expect(transform([sensitive])).to eq(["#<Sensitive [value redacted]:#{id}>"])
+  end
+
+  it 'converts the content of a hash - for example a Sensitive value' do
+    sensitive = evaluate(source: "Sensitive('hush')")
+    id = sensitive.object_id
+    expect(transform({'x' => sensitive})).to eq({'x' => "#<Sensitive [value redacted]:#{id}>"})
+  end
+
+  it 'does not convert a hash' do
+    expect(transform({'a' => 10, 'b' => 20})).to eq({'a' => 10, 'b' => 20})
+  end
+
+  it 'converts non Data compliant hash key to string' do
+    expect(transform({['funky', 'key'] => 10})).to eq({'["funky", "key"]' => 10})
+  end
+
+  it 'converts reserved __ptype hash key to different string' do
+    expect(transform({'__ptype' => 10})).to eq({'reserved key: __ptype' => 10})
+  end
+
+  it 'converts reserved __pvalue hash key to different string' do
+    expect(transform({'__pvalue' => 10})).to eq({'reserved key: __pvalue' => 10})
+  end
+
+  it 'converts a Binary to Base64 string' do
+    expect(eval_transform("Binary('hello', '%s')")).to eq("aGVsbG8=")
+  end
+
+  it 'converts an ASCII-8BIT String to Base64 String' do
+    binary_string = "\x02\x03\x04hello".force_encoding('ascii-8bit')
+    expect(transform(binary_string)).to eq("AgMEaGVsbG8=")
+  end
+
+  it 'converts Runtime (alien) object to its to_s' do
+    class Alien
+    end
+    an_alien = Alien.new
+    expect(transform(an_alien)).to eq(an_alien.to_s)
+  end
+
+  it 'converts a runtime Symbol to String' do
+    expect(transform(:symbolic)).to eq("symbolic")
+  end
+
+  it 'converts a datatype (such as Integer[0,10]) to its puppet source string form' do
+    expect(eval_transform("Integer[0,100]")).to eq("Integer[0, 100]")
+  end
+
+  it 'converts a user defined datatype (such as Car) to its puppet source string form' do
+    result = evaluate(code: "type Car = Object[attributes=>{regnbr => String}]", source: "Car")
+    expect(transform(result)).to eq("Car")
+  end
+
+  it 'converts a self referencing user defined datatype by using named references for cyclic entries' do
+    result = evaluate(code: "type Tree = Array[Variant[String, Tree]]", source: "Tree")
+    expect(transform(result)).to eq("Tree = Array[Variant[String, Tree]]")
+  end
+
+  it 'converts illegal char sequence in an encoding to Unicode Illegal' do
+    invalid_sequence = [0xc2, 0xc2].pack("c*").force_encoding(Encoding::UTF_8)
+    expect(transform(invalid_sequence)).to eq("��")
+  end
+
+  it 'does not convert unassigned char - glyph is same for all unassigned' do
+    unassigned = [243, 176, 128, 128].pack("C*").force_encoding(Encoding::UTF_8) 
+    expect(transform(unassigned)).to eq("󰀀")
+  end
+
+  it 'converts ProcessOutput objects to string' do
+    object = Puppet::Util::Execution::ProcessOutput.new('object', 0)
+    expect(transform(object)).to be_instance_of(String)
+  end
+end

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

@@ -0,0 +1,87 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet_spec/compiler'
+
+module Puppet::Pops
+  module Types
+    describe 'Deferred type' do
+      context 'when used in Puppet expressions' do
+        include PuppetSpec::Compiler
+        it 'is equal to itself only' do
+          expect(eval_and_collect_notices(<<-CODE)).to eq(%w(true true false false))
+            $t = Deferred
+            notice(Deferred =~ Type[Deferred])
+            notice(Deferred == Deferred)
+            notice(Deferred < Deferred)
+            notice(Deferred > Deferred)
+            CODE
+        end
+
+        context 'a Deferred instance' do
+          it 'can be created using positional arguments' do
+            code = <<-CODE
+              $o = Deferred('michelangelo', [1,2,3])
+              notice($o)
+              CODE
+            expect(eval_and_collect_notices(code)).to eq([
+              "Deferred({'name' => 'michelangelo', 'arguments' => [1, 2, 3]})"
+            ])
+          end
+
+          it 'can be created using named arguments' do
+            code = <<-CODE
+              $o = Deferred(name =>'michelangelo', arguments => [1,2,3])
+              notice($o)
+              CODE
+            expect(eval_and_collect_notices(code)).to eq([
+              "Deferred({'name' => 'michelangelo', 'arguments' => [1, 2, 3]})"
+            ])
+          end
+
+          it 'is inferred to have the type Deferred' do
+            pending 'bug in type() function outputs the entire pcore definition'
+            code = <<-CODE
+              $o = Deferred('michelangelo', [1,2,3])
+              notice(type($o))
+              CODE
+            expect(eval_and_collect_notices(code)).to eq([
+              "Deferred"
+            ])
+          end
+
+          it 'exposes name' do
+            code = <<-CODE
+              $o = Deferred(name =>'michelangelo', arguments => [1,2,3])
+              notice($o.name)
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(["michelangelo"])
+          end
+
+          it 'exposes arguments' do
+            code = <<-CODE
+              $o = Deferred(name =>'michelangelo', arguments => [1,2,3])
+              notice($o.arguments)
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(["[1, 2, 3]"])
+          end
+
+          it 'is an instance of its inferred type' do
+            code = <<-CODE
+              $o = Deferred(name =>'michelangelo', arguments => [1,2,3])
+              notice($o =~ type($o))
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(['true'])
+          end
+
+          it 'is an instance of Deferred' do
+            code = <<-CODE
+              $o = Deferred(name =>'michelangelo', arguments => [1,2,3])
+              notice($o =~ Deferred)
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(['true'])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,207 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet_spec/compiler'
+
+module Puppet::Pops
+  module Types
+    describe 'Error type' do
+      context 'when used in Puppet expressions' do
+        include PuppetSpec::Compiler
+        it 'is equal to itself only' do
+          expect(eval_and_collect_notices(<<-CODE)).to eq(%w(true true false false))
+            $t = Error
+            notice(Error =~ Type[Error])
+            notice(Error == Error)
+            notice(Error < Error)
+            notice(Error > Error)
+            CODE
+        end
+
+        context "when parameterized" do
+          it 'is equal other types with the same parameterization' do
+            code = <<-CODE
+              notice(Error['puppet/error'] == Error['puppet/error', default])
+              notice(Error['puppet/error', 'ouch'] == Error['puppet/error', 'ouch'])
+              notice(Error['puppet/error', 'ouch'] != Error['puppet/error', 'ouch!'])
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(%w(true true true))
+          end
+
+          it 'is assignable from more qualified types' do
+            expect(eval_and_collect_notices(<<-CODE)).to eq(%w(true true true))
+              notice(Error > Error['puppet/error'])
+              notice(Error['puppet/error'] > Error['puppet/error', 'ouch'])
+              notice(Error['puppet/error', default] > Error['puppet/error', 'ouch'])
+              CODE
+          end
+
+          it 'is not assignable unless kind is assignable' do
+            expect(eval_and_collect_notices(<<-CODE)).to eq(%w(true false true false true false true))
+              notice(Error[/a/] > Error['hah'])
+              notice(Error[/a/] > Error['hbh'])
+              notice(Error[Enum[a,b,c]] > Error[a])
+              notice(Error[Enum[a,b,c]] > Error[d])
+              notice(Error[Pattern[/a/, /b/]] > Error[a])
+              notice(Error[Pattern[/a/, /b/]] > Error[c])
+              notice(Error[Pattern[/a/, /b/]] > Error[Enum[a, b]])
+              CODE
+          end
+
+          it 'presents parsable string form' do
+            code = <<-CODE
+              notice(Error['a'])
+              notice(Error[/a/])
+              notice(Error[Enum['a', 'b']])
+              notice(Error[Pattern[/a/, /b/]])
+              notice(Error['a', default])
+              notice(Error[/a/, default])
+              notice(Error[Enum['a', 'b'], default])
+              notice(Error[Pattern[/a/, /b/], default])
+              notice(Error[default,'a'])
+              notice(Error[default,/a/])
+              notice(Error[default,Enum['a', 'b']])
+              notice(Error[default,Pattern[/a/, /b/]])
+              notice(Error['a','a'])
+              notice(Error[/a/,/a/])
+              notice(Error[Enum['a', 'b'],Enum['a', 'b']])
+              notice(Error[Pattern[/a/, /b/],Pattern[/a/, /b/]])
+              CODE
+            expect(eval_and_collect_notices(code)).to eq([
+              "Error['a']",
+              'Error[/a/]',
+              "Error[Enum['a', 'b']]",
+              "Error[Pattern[/a/, /b/]]",
+              "Error['a']",
+              'Error[/a/]',
+              "Error[Enum['a', 'b']]",
+              "Error[Pattern[/a/, /b/]]",
+              "Error[default, 'a']",
+              'Error[default, /a/]',
+              "Error[default, Enum['a', 'b']]",
+              "Error[default, Pattern[/a/, /b/]]",
+              "Error['a', 'a']",
+              'Error[/a/, /a/]',
+              "Error[Enum['a', 'b'], Enum['a', 'b']]",
+              "Error[Pattern[/a/, /b/], Pattern[/a/, /b/]]",
+            ])
+          end
+        end
+
+        context 'an Error instance' do
+          it 'can be created using positional arguments' do
+            code = <<-CODE
+              $o = Error('bad things happened', 'puppet/error', {'detail' => 'val'}, 'OOPS')
+              notice($o)
+              notice(type($o))
+              CODE
+            expect(eval_and_collect_notices(code)).to eq([
+              "Error({'msg' => 'bad things happened', 'kind' => 'puppet/error', 'details' => {'detail' => 'val'}, 'issue_code' => 'OOPS'})",
+              "Error['puppet/error', 'OOPS']"
+            ])
+          end
+
+          it 'can be created using named arguments' do
+            code = <<-CODE
+              $o = Error(msg => 'Sorry, not implemented', kind => 'puppet/error', issue_code => 'NOT_IMPLEMENTED')
+              notice($o)
+              notice(type($o))
+              CODE
+            expect(eval_and_collect_notices(code)).to eq([
+              "Error({'msg' => 'Sorry, not implemented', 'kind' => 'puppet/error', 'issue_code' => 'NOT_IMPLEMENTED'})",
+              "Error['puppet/error', 'NOT_IMPLEMENTED']"
+            ])
+          end
+
+          it 'exposes message' do
+            code = <<-CODE
+              $o = Error(msg => 'Sorry, not implemented', kind => 'puppet/error', issue_code => 'NOT_IMPLEMENTED')
+              notice($o.message)
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(["Sorry, not implemented"])
+          end
+
+          it 'exposes kind' do
+            code = <<-CODE
+              $o = Error(msg => 'Sorry, not implemented', kind => 'puppet/error', issue_code => 'NOT_IMPLEMENTED')
+              notice($o.kind)
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(["puppet/error"])
+          end
+
+          it 'exposes issue_code' do
+            code = <<-CODE
+              $o = Error(msg => 'Sorry, not implemented', kind => 'puppet/error', issue_code => 'NOT_IMPLEMENTED')
+              notice($o.issue_code)
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(["NOT_IMPLEMENTED"])
+          end
+
+          it 'exposes details' do
+            code = <<-CODE
+              $o = Error(msg => 'Sorry, not implemented', kind => 'puppet/error', details => { 'detailk' => 'detailv' })
+              notice($o.details)
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(["{detailk => detailv}"])
+          end
+
+          it 'is an instance of its inferred type' do
+            code = <<-CODE
+              $o = Error('bad things happened', 'puppet/error')
+              notice($o =~ type($o))
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(['true'])
+          end
+
+          it 'is an instance of Error with matching kind' do
+            code = <<-CODE
+              $o = Error('bad things happened', 'puppet/error')
+              notice($o =~ Error[/puppet\\/error/])
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(['true'])
+          end
+
+          it 'is an instance of Error with matching issue_code' do
+            code = <<-CODE
+              $o = Error('bad things happened', 'puppet/error', {}, 'FEE')
+              notice($o =~ Error[default, 'FEE'])
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(['true'])
+          end
+
+          it 'is an instance of Error with matching kind and issue_code' do
+            code = <<-CODE
+              $o = Error('bad things happened', 'puppet/error', {}, 'FEE')
+              notice($o =~ Error['puppet/error', 'FEE'])
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(['true'])
+          end
+
+          it 'is not an instance of Error unless kind matches' do
+            code = <<-CODE
+              $o = Error('bad things happened', 'puppetlabs/error')
+              notice($o =~ Error[/puppet\\/error/])
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(['false'])
+          end
+
+          it 'is not an instance of Error unless issue_code matches' do
+            code = <<-CODE
+              $o = Error('bad things happened', 'puppetlabs/error', {}, 'BAR')
+              notice($o =~ Error[default, 'FOO'])
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(['false'])
+          end
+
+          it 'is not an instance of Error unless both kind and issue is a match' do
+            code = <<-CODE
+              $o = Error('bad things happened', 'puppet/error', {}, 'FEE')
+              notice($o =~ Error['puppetlabs/error', 'FEE'])
+              notice($o =~ Error['puppet/error', 'FUM'])
+              CODE
+            expect(eval_and_collect_notices(code)).to eq(['false', 'false'])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -230,7 +230,7 @@ describe 'The iterable support' do
     include Enumerable
     include Iterable
 
-     def step(step_size)
+    def step(step_size)
       if block_given?
         begin
           current = 0