puppet 4.10.0 → 5.0.0

data/spec/unit/functions/lookup_spec.rb

@@ -438,6 +438,30 @@ describe "The lookup function" do
       expect(lookup('a')).to eql('value a (from environment)')
     end
 
+    context 'with log-level debug' do
+      before(:each) { Puppet[:log_level] = 'debug' }
+
+      it 'does not report a regular lookup as APL' do
+        expect(lookup('a')).to eql('value a (from environment)')
+        expect(debugs.count { |dbg| dbg =~ /\A\s*Automatic Parameter Lookup of/ }).to eql(0)
+      end
+
+      it 'reports regular lookup as lookup' do
+        expect(lookup('a')).to eql('value a (from environment)')
+        expect(debugs.count { |dbg| dbg =~ /\A\s*Lookup of/ }).to eql(1)
+      end
+
+      it 'does not report APL as lookup' do
+        collect_notices("class mod_a($a) { notice($a) }; include mod_a")
+        expect(debugs.count { |dbg| dbg =~ /\A\s*Lookup of/ }).to eql(0)
+      end
+
+      it 'reports APL as APL' do
+        collect_notices("class mod_a($a) { notice($a) }; include mod_a")
+        expect(debugs.count { |dbg| dbg =~ /\A\s*Automatic Parameter Lookup of/ }).to eql(1)
+      end
+    end
+
     context 'that has no lookup configured' do
       let(:environment_files) do
         {
@@ -818,6 +842,24 @@ describe "The lookup function" do
           end
         end
       end
+
+      context 'that contains an array with duplicates' do
+        let(:common_yaml) { <<-YAML.unindent }
+          a:
+           - alpha
+           - bravo
+           - charlie
+           - bravo
+          YAML
+
+        it 'retains the duplicates when using default merge strategy' do
+          expect(lookup('a')).to eql(%w(alpha bravo charlie bravo))
+        end
+
+        it 'does deduplification when using merge strategy "unique"' do
+          expect(lookup('a', :merge => 'unique')).to eql(%w(alpha bravo charlie))
+        end
+      end
     end
 
     context 'with lookup_options configured using patterns' do
@@ -2056,8 +2098,9 @@ describe "The lookup function" do
             }
           end
 
-          it 'raises an error' do
-            expect { lookup('mod_a::a') }.to raise_error(Puppet::Error, /hiera.yaml version 3 cannot be used in a module/)
+          it 'raises a warning' do
+            expect(lookup('mod_a::a')).to eql('value mod_a::a (from environment)')
+            expect(warnings).to include(/hiera.yaml version 3 found at module root was ignored/)
           end
         end
 
@@ -2107,6 +2150,53 @@ describe "The lookup function" do
         end
       end
 
+      context 'using deep merge and module values that aliases environment values' do
+        let(:mod_a_files) do
+          {
+            'mod_a' => {
+              'data' => {
+                'common.yaml' => <<-YAML.unindent,
+                  ---
+                  mod_a::hash:
+                    b: value b (from module)
+                  lookup_options:
+                    mod_a::hash:
+                      merge: deep
+                  YAML
+              },
+              'hiera.yaml' => <<-YAML.unindent,
+                ---
+                version: 5
+                hierarchy:
+                  - name: "Common"
+                    path: "common.yaml"
+                  - name: "Other"
+                    path: "other.yaml"
+                YAML
+            }
+          }
+        end
+        let(:env_data) do
+          {
+            'common.yaml' => <<-YAML.unindent
+              a: value a (from environment)
+              mod_a::hash:
+                a: value mod_a::hash.a (from environment)
+                c: '%{alias("a")}'
+              YAML
+          }
+        end
+
+        it 'continues with module lookup after alias is resolved in environment' do
+          expect(lookup('mod_a::hash')).to eql(
+            {
+              'a' => 'value mod_a::hash.a (from environment)',
+              'b' => 'value b (from module)',
+              'c' => 'value a (from environment)'
+            })
+        end
+      end
+
       context 'using a data_hash that reads a yaml file' do
         let(:defaults) {
           {
@@ -2442,7 +2532,7 @@ describe "The lookup function" do
 
           it 'fails and reports error' do
             expect{lookup('mod_a::a')}.to raise_error(
-              "Return type of 'lookup_key' function named 'mod_a::pp_lookup_key' is incorrect, expects a value of type Undef, Scalar, Sensitive, Type, Hash, or Array, got Runtime")
+              "Return type of 'lookup_key' function named 'mod_a::pp_lookup_key' is incorrect, expects a RichData value, got Runtime")
           end
         end
       end
@@ -2875,6 +2965,121 @@ describe "The lookup function" do
 
       let(:env_data) { data_files }
 
+      context 'and a module using eyaml with different options' do
+
+        let(:private_module_key) do
+          <<-PKCS7.unindent
+          -----BEGIN RSA PRIVATE KEY-----
+          MIIEogIBAAKCAQEAuqVpctipK4OMWM+RwKcd/mR4pg6qE3+ItPVC9TlvBrmDaN/y
+          YZRjQR+XovXSGuy/CneSQ9Qss0Ff3FKAmEeH0qN0V47a81hgLpjhLCX1n+Ov7r1Q
+          DC1ciTpVzHE4krN3rJ/RmDohitIqT1IYYhdcEdaMG9E26HIzn1QIwaDiYU3mfqWM
+          8CZExa0CeIsEzHRLSxuMi/xX0ENImCRUzY9GH88Cu2gUhpKlbVzJmVqGPgp94pJY
+          YM+SUb0XP1yRySpJMnVg98oCUrQO2OoE/Gax/djAi6hrJUzejPsEKdZ1yxM6OyJW
+          NjWZYs8izAxBqm7pv1hx5+X7AIPqwZTMVrB7TQIDAQABAoIBAHIex13QOYeAlGSM
+          7bpUtBMiTV6DItxvIyA5wen8ZvU+oqmSHDorp5BfB7E9Cm0qChkVSRot9fLYawtk
+          anoxakuRY4ZRs3AMvipfkXYT854CckTP/cykQ6soPuOU6plQIEEtKtMf3/hoTjRX
+          ps77J3FEtEAh6Kexg/zMPdpeS2xgULhk0P9ZQEg+JhLA5dq0p0nz3SBkuzcxei79
+          +Za/Tg1osD0AINOajdvPnKxvlmWJN0+LpGwVjFNhkoUXPeDyvq0z2V/Uqwz4HP2I
+          UGv4tz3SbzFc3Ie4lzgUZzCQgUK3u60pq1uyA6BRtxwdEmpn5v++jGXBGJZpWwcW
+          UNblESUCgYEA4aTH9+LHsNjLPs2FmSc7hNjwHG1rAHcDXTX2ccySjRcQvH4Z7xBL
+          di+SzZ2Tf8gSLycPRgRVCbrgCODpjoV2D5wWnyUHfWm4+GQxHURYa4UDx69tsSKE
+          OTRASJo7/Mz0M1a6YzgCzVRM/TO676ucmawzKUY5OUm1oehtODAiZOcCgYEA08GM
+          AMBOznys02xREJI5nLR6AveuTbIjF2efEidoxoW+1RrMOkcqaDTrJQ5PLM+oDDwD
+          iPzVjnroSbwJzFB71atIg7b7TwltgkXy7wNTedO2cm5u/I0q8tY2Jaa4Mz8JUnbe
+          yafvtS0/mY6A5k+8/2UIMFin2rqU9NC9EUPIo6sCgYBhOvAwELibq89osIbxB8bN
+          5+0PUtbYzG/WqnoXb193DIlZr7zdFththPJtR4lXdo7fYqViNluuZahEKyZ5E2lc
+          MJZO3VXs5LGf1wyS3/B55EdMtHs/6O+w9qL8pflTZb2UobqPJoOOltTWBoR24iwI
+          y/r/vhLKbMini9AEdjlb4QKBgGdYsax4Lr4GCQ8ScSnmQ6ngRyAFo5MV2pyEnRTu
+          GOuywKUe9AeJTgAXu5+VMT0Mh9aYv5zu0Ic+IvpBhIKr0RRCCR0Hg/VaA5Et9FeE
+          RwxRMFz+2rn1Z72moDyV9pZEMJeHnknK5WmGEOEvtGczCWmX9Hwr+Jf+sc4dxfiU
+          HWsLAoGAXWSX73p/6R4eRfF5zU2UFJPvDzhmwObAuvU4zKs9x7PMxZfvyt/eBCO1
+          fj2+hIR72RxVuHbLApF1BT6gPVLtNdvaNuCs8YlHcnx/Oi088F0ni7fL/xYBUvaB
+          7wTf188UJxP1ofVMZW00P4I9mR6BrOulv455gCwsmg2X7WtJU48=
+          -----END RSA PRIVATE KEY-----
+          PKCS7
+        end
+
+        let(:public_module_key) do
+          <<-PKCS7.unindent
+          -----BEGIN CERTIFICATE-----
+          MIIC2TCCAcGgAwIBAgIBATANBgkqhkiG9w0BAQUFADAAMCAXDTE3MDUzMTE2Mjc0
+          M1oYDzIwNjcwNTE5MTYyNzQzWjAAMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB
+          CgKCAQEAuqVpctipK4OMWM+RwKcd/mR4pg6qE3+ItPVC9TlvBrmDaN/yYZRjQR+X
+          ovXSGuy/CneSQ9Qss0Ff3FKAmEeH0qN0V47a81hgLpjhLCX1n+Ov7r1QDC1ciTpV
+          zHE4krN3rJ/RmDohitIqT1IYYhdcEdaMG9E26HIzn1QIwaDiYU3mfqWM8CZExa0C
+          eIsEzHRLSxuMi/xX0ENImCRUzY9GH88Cu2gUhpKlbVzJmVqGPgp94pJYYM+SUb0X
+          P1yRySpJMnVg98oCUrQO2OoE/Gax/djAi6hrJUzejPsEKdZ1yxM6OyJWNjWZYs8i
+          zAxBqm7pv1hx5+X7AIPqwZTMVrB7TQIDAQABo1wwWjAPBgNVHRMBAf8EBTADAQH/
+          MB0GA1UdDgQWBBQkhoMgOyPzEe7tOOimNH2//PYF2TAoBgNVHSMEITAfgBQkhoMg
+          OyPzEe7tOOimNH2//PYF2aEEpAIwAIIBATANBgkqhkiG9w0BAQUFAAOCAQEAhRWc
+          Nz3PcUJllao5G/v4AyvjLgwB2JgjJgh6D3ILoOe9TrDSXD7ZV3F30vFae+Eztk86
+          pmM8x57E0HsuuY+Owf6/hvELtwbzf9N/lc9ySZSogGFoQeJ8rnCJAQ0FaPjqb7AN
+          xTaY9HTzr4dZG1f+sw32RUu2fDe7Deqgf85uMSZ1mtRTt9zvo8lMQxVA2nVOfwz2
+          Nxf+qSNYSCtf0/6iwfzHy0qPjaJnywgBCi3Lg2IMSqGUatxzH+9HWrBgD+ZYxmDz
+          2gW+EIU1Y/We/tbjIWaR1PD+IzeRJi5fHq60RKHPSdp7TGtV48bQRvyZXC7sVCRa
+          yxfX1IGYhCDzbFRQNg==
+          -----END CERTIFICATE-----
+          PKCS7
+        end
+
+        let(:module_keys_dir) do
+          keys = tmpdir('keys')
+          dir_contained_in(keys, {
+            private_key_name => private_module_key,
+            public_key_name => public_module_key
+          })
+          keys
+        end
+
+        let(:private_module_key_path) { File.join(module_keys_dir, private_key_name) }
+        let(:public_module_key_path) { File.join(module_keys_dir, public_key_name) }
+
+        let(:mod_a_files) do
+          {
+            'mod_a' => {
+              'hiera.yaml' => <<-YAML.unindent,
+                version: 5
+                hierarchy:
+                  - name: EYaml
+                    path: common.eyaml
+                    lookup_key: eyaml_lookup_key
+                    options:
+                      pkcs7_private_key: #{private_module_key_path}
+                      pkcs7_public_key: #{public_module_key_path}
+                YAML
+              'data' => {
+                'common.eyaml' => <<-YAML.unindent
+                ---
+                # "%{lookup('a')} (from module)"
+                mod_a::a: >
+                  ENC[PKCS7,MIIBiQYJKoZIhvcNAQcDoIIBejCCAXYCAQAxggEhMIIBHQIBADAFMAACAQEw
+                  DQYJKoZIhvcNAQEBBQAEggEAC+lvda8mX6XkgCBstNw4IQUDyFcS6M0mS9gZ
+                  ev4VBDeUK4AUNVnzzdbW0Mnj9LbqlpzFx96VGqSxsRBpe7BVD0kVo5jQsEMn
+                  nbrWOD1lvXYrXZMXBeD9xJbMbH5EiiFhbaXcEKRAVGaLVQKjXDENDQ/On+it
+                  1+wmmVwJynDJR0lsCz6dcSKvw6wnxBcv32qFyePvJuIf04CHMhaS4ykedYHK
+                  vagUn5uVXOv/8G0JPlZnQLyxjE0v0heb0Zj0mvcP2+Y5BSW50AQVrMWJNtdW
+                  aFEg6H5hpjduQfQh3iWVuDLnWhbP0sY2Grn5dTOxQP8aTDSsiTUcSeIAmjr/
+                  K8YRCjBMBgkqhkiG9w0BBwEwHQYJYIZIAWUDBAEqBBAjL7InlBjRuohLLcBx
+                  686ogCDkhCan8bCE7aX2nr75QtLF3q89pFIR4/NGl5+oGEO+qQ==]
+                YAML
+              }
+            }
+          }
+        end
+
+        let(:populated_env_dir) do
+          dir_contained_in(env_dir, DeepMerge.deep_merge!(environment_files, env_name => { 'modules' => mod_a_files }))
+          env_dir
+        end
+
+        it 'repeatedly finds data in environment and module' do
+          expect(lookup(['array_a', 'mod_a::a', 'hash_a'])).to eql([
+            ['array_a[0]', 'array_a[1]'],
+            "Encrypted value 'a' (from environment) (from module)",
+            {'hash_aa'=>{'aaa'=>'Encrypted value hash_a.hash_aa.aaa (from environment)'}}])
+        end
+      end
+
       it 'finds data in the environment' do
         expect(lookup('a')).to eql("Encrypted value 'a' (from environment)")
       end

data/spec/unit/functions/new_spec.rb

@@ -532,7 +532,7 @@ describe 'the new function' do
   context 'when invoked on Array' do
     { []            => 'Notify[Array[Unit], []]',
       [true]        => 'Notify[Array[Boolean], [true]]',
-      {'a'=>true, 'b' => false}   => 'Notify[Array[Array[Scalar]], [[a, true], [b, false]]]',
+      {'a'=>true, 'b' => false}   => 'Notify[Array[Array[ScalarData]], [[a, true], [b, false]]]',
       'abc'         => 'Notify[Array[String[1, 1]], [a, b, c]]',
       3             => 'Notify[Array[Integer], [0, 1, 2]]',
     }.each do |input, result|

data/spec/unit/functions/unique_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the unique function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  context 'produces the unique set of chars from a String such that' do
+    it 'same case is considered unique' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, "abc")
+          notify{ 'test': message => 'abcbbcc'.unique }
+        SOURCE
+    end
+
+    it 'different case is not considered unique' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, "abcABC")
+          notify{ 'test': message => 'abcAbbBccC'.unique }
+        SOURCE
+    end
+
+    it 'case independent matching can be performed with a lambda' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, "abc")
+          notify{ 'test': message => 'abcAbbBccC'.unique |$x| { String($x, '%d') } }
+        SOURCE
+    end
+
+    it 'the first found value in the unique set is used' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, "AbC")
+          notify{ 'test': message => 'AbCAbbBccC'.unique |$x| { String($x, '%d') } }
+        SOURCE
+    end
+  end
+
+  context 'produces the unique set of values from an Array such that' do
+    it 'ruby equality is used to compute uniqueness by default' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, ['a', 'b', 'c', 'B', 'C'])
+          notify{ 'test': message => [a, b, c, a, 'B', 'C'].unique }
+        SOURCE
+    end
+
+    it 'accepts a lambda to perform the value to use for uniqueness' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, ['a', 'b', 'c'])
+          notify{ 'test': message => [a, b, c, a, 'B', 'C'].unique |$x| { String($x, '%d') }}
+        SOURCE
+    end
+
+    it 'the first found value in the unique set is used' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, ['A', 'b', 'C'])
+          notify{ 'test': message => ['A', b, 'C', a, 'B', 'c'].unique |$x| { String($x, '%d') }}
+        SOURCE
+    end
+  end
+
+  context 'produces the unique set of values from an Hash such that' do
+    it 'resulting keys and values in hash are arrays' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, {['a'] => [10], ['b']=>[20]})
+          notify{ 'test': message => {a => 10, b => 20}.unique }
+        SOURCE
+    end
+
+    it 'resulting keys contain all keys with same value' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, {['a', 'b'] => [10], ['c']=>[20]})
+          notify{ 'test': message => {a => 10, b => 10, c => 20}.unique }
+        SOURCE
+    end
+
+    it 'resulting values contain Ruby == unique set of values' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, {['a'] => [10], ['b', 'c']=>[11, 20]})
+          notify{ 'test': message => {a => 10, b => 11, c => 20}.unique |$x| { if $x > 10 {bigly} else { $x }}}
+        SOURCE
+    end
+  end
+
+  context 'produces the unique set of values from an Iterable' do
+    it 'such as reverse_each - in reverse order' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, ['B','b','a'])
+          notify{ 'test': message => ['a', 'b', 'B'].reverse_each.unique }
+        SOURCE
+    end
+
+    it 'such as Integer[1,5]' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, [1,2,3,4,5])
+          notify{ 'test': message => Integer[1,5].unique }
+        SOURCE
+    end
+
+    it 'such as the Integer 3' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, [0,1,2])
+          notify{ 'test': message => 3.unique }
+        SOURCE
+    end
+
+    it 'allows lambda to be used with Iterable' do
+      expect(compile_to_catalog(<<-SOURCE)).to have_resource('Notify[test]').with_parameter(:message, ['B','a'])
+          notify{ 'test': message => ['a', 'b', 'B'].reverse_each.unique |$x| { String($x, '%d') }}
+        SOURCE
+    end
+  end
+
+  it 'errors when given unsupported data type as input' do
+    expect do
+      compile_to_catalog(<<-SOURCE)
+        undef.unique
+      SOURCE
+    end.to raise_error(/expects an Iterable value, got Undef/)
+  end
+
+
+end

data/spec/unit/functions4_spec.rb

@@ -200,7 +200,7 @@ describe 'the 4x function api' do
     it 'a function can use inexact argument mapping' do
       f = create_function_with_inexact_dispatch
       func = f.new(:closure_scope, :loader)
-      expect(func.call({}, 3,4,5)).to eql([Fixnum, Fixnum, Fixnum])
+      expect(func.call({}, 3.0,4.0,5.0)).to eql([Float, Float, Float])
       expect(func.call({}, 'Apple', 'Banana')).to eql([String, String])
     end
 
@@ -253,35 +253,6 @@ describe 'the 4x function api' do
       end
     end
 
-    context 'can use injection' do
-      before :all do
-        injector = Puppet::Pops::Binder::Injector.create('test') do
-          bind.name('a_string').to('evoe')
-          bind.name('an_int').to(42)
-        end
-        Puppet.push_context({:injector => injector}, "injector for testing function API")
-      end
-
-      after :all do
-        Puppet.pop_context()
-      end
-
-      it 'attributes can be injected' do
-        f1 = create_function_with_class_injection()
-        f = f1.new(:closure_scope, :loader)
-        expect(f.test_attr2()).to eql("evoe")
-        expect(f.serial().produce(nil)).to eql(42)
-        expect(f.test_attr().class.name).to eql("FunctionAPISpecModule::TestDuck")
-      end
-
-      it 'parameters can be injected and woven with regular dispatch' do
-        f1 = create_function_with_param_injection_regular()
-        f = f1.new(:closure_scope, :loader)
-        expect(f.call(nil, 10, 20)).to eql("evoe! 10, and 20 < 42 = true")
-        expect(f.call(nil, 50, 20)).to eql("evoe! 50, and 20 < 42 = false")
-      end
-    end
-
     context 'when requesting a type' do
       it 'responds with a Callable for a single signature' do
         tf = Puppet::Pops::Types::TypeFactory
@@ -839,18 +810,6 @@ describe 'the 4x function api' do
     end
   end
 
-  def create_function_with_class_injection
-    f = Puppet::Functions.create_function('test', Puppet::Functions::InternalFunction) do
-      attr_injected Puppet::Pops::Types::TypeFactory.type_of(FunctionAPISpecModule::TestDuck), :test_attr
-      attr_injected Puppet::Pops::Types::TypeFactory.string(), :test_attr2, "a_string"
-      attr_injected_producer Puppet::Pops::Types::TypeFactory.integer(), :serial, "an_int"
-
-      def test(x,y,a=1, b=1, *c)
-        x <= y ? x : y
-      end
-    end
-  end
-
   def create_function_with_param_injection_regular
     f = Puppet::Functions.create_function('test', Puppet::Functions::InternalFunction) do
       attr_injected Puppet::Pops::Types::TypeFactory.type_of(FunctionAPISpecModule::TestDuck), :test_attr
@@ -999,7 +958,7 @@ describe 'the 4x function api' do
   end
 
   def type_alias_t(name, type_string)
-    type_expr = Puppet::Pops::Parser::EvaluatingParser.new.parse_string(type_string).current
+    type_expr = Puppet::Pops::Parser::EvaluatingParser.new.parse_string(type_string)
     Puppet::Pops::Types::TypeFactory.type_alias(name, type_expr)
   end
 

data/spec/unit/graph/simple_graph_spec.rb

@@ -296,32 +296,37 @@ describe Puppet::Graph::SimpleGraph do
       end
     end
 
-    it "should fail on two-vertex loops" do
+    def expect_cycle_to_include(cycle, *resource_names)
+      resource_names.each_with_index do |resource, index|
+        expect(cycle[index].ref).to eq("Notify[#{resource}]")
+      end
+    end
+
+    it "should report two-vertex loops" do
       add_edges :a => :b, :b => :a
-      expect { @graph.report_cycles_in_graph }.to raise_error(Puppet::Error)
+      Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:\n\(Notify\[a\] => Notify\[b\] => Notify\[a\]\)/))
+      cycle = @graph.report_cycles_in_graph.first
+      expect_cycle_to_include(cycle, :a, :b)
     end
 
-    it "should fail on multi-vertex loops" do
+    it "should report multi-vertex loops" do
       add_edges :a => :b, :b => :c, :c => :a
-      expect { @graph.report_cycles_in_graph }.to raise_error(Puppet::Error)
+      Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:\n\(Notify\[a\] => Notify\[b\] => Notify\[c\] => Notify\[a\]\)/))
+      cycle = @graph.report_cycles_in_graph.first
+      expect_cycle_to_include(cycle, :a, :b, :c)
     end
 
-    it "should fail when a larger tree contains a small cycle" do
+    it "should report when a larger tree contains a small cycle" do
       add_edges :a => :b, :b => :a, :c => :a, :d => :c
-      expect { @graph.report_cycles_in_graph }.to raise_error(Puppet::Error)
+      Puppet.expects(:err).with(regexp_matches(/Found 1 dependency cycle:\n\(Notify\[a\] => Notify\[b\] => Notify\[a\]\)/))
+      cycle = @graph.report_cycles_in_graph.first
+      expect_cycle_to_include(cycle, :a, :b)
     end
 
     it "should succeed on trees with no cycles" do
       add_edges :a => :b, :b => :e, :c => :a, :d => :c
-      expect { @graph.report_cycles_in_graph }.to_not raise_error
-    end
-
-    it "should produce the correct relationship text" do
-      add_edges :a => :b, :b => :a
-      # cycle detection starts from a or b randomly
-      # so we need to check for either ordering in the error message
-      want = %r{Found 1 dependency cycle:\n\((Notify\[a\] => Notify\[b\] => Notify\[a\]|Notify\[b\] => Notify\[a\] => Notify\[b\])\)\nTry}
-      expect { @graph.report_cycles_in_graph }.to raise_error(Puppet::Error, want)
+      Puppet.expects(:err).never
+      expect(@graph.report_cycles_in_graph).to be_nil
     end
 
     it "cycle discovery should be the minimum cycle for a simple graph" do
@@ -528,31 +533,31 @@ describe Puppet::Graph::SimpleGraph do
     end
 
     def one_vertex_graph(graph)
-      graph.add_vertex(:a)
+      graph.add_vertex('a')
     end
 
     def graph_without_edges(graph)
-      [:a, :b, :c].each { |x| graph.add_vertex(x) }
+      ['a', 'b', 'c'].each { |x| graph.add_vertex(x) }
     end
 
     def one_edge_graph(graph)
-      graph.add_edge(:a, :b)
+      graph.add_edge('a', 'b')
     end
 
     def many_edge_graph(graph)
-      graph.add_edge(:a, :b)
-      graph.add_edge(:a, :c)
-      graph.add_edge(:b, :d)
-      graph.add_edge(:c, :d)
+      graph.add_edge('a', 'b')
+      graph.add_edge('a', 'c')
+      graph.add_edge('b', 'd')
+      graph.add_edge('c', 'd')
     end
 
     def labeled_edge_graph(graph)
-      graph.add_edge(:a, :b, :callback => :foo, :event => :bar)
+      graph.add_edge('a', 'b', :callback => :foo, :event => :bar)
     end
 
     def overlapping_edge_graph(graph)
-      graph.add_edge(:a, :b, :callback => :foo, :event => :bar)
-      graph.add_edge(:a, :b, :callback => :biz, :event => :baz)
+      graph.add_edge('a', 'b', :callback => :foo, :event => :bar)
+      graph.add_edge('a', 'b', :callback => :biz, :event => :baz)
     end
 
     def self.all_test_graphs
@@ -569,7 +574,11 @@ describe Puppet::Graph::SimpleGraph do
     def graph_to_yaml(graph, which_format)
       previous_use_new_yaml_format = Puppet::Graph::SimpleGraph.use_new_yaml_format
       Puppet::Graph::SimpleGraph.use_new_yaml_format = (which_format == :new)
-      YAML.dump(graph)
+      if block_given?
+        yield
+      else
+        YAML.dump(graph)
+      end
     ensure
       Puppet::Graph::SimpleGraph.use_new_yaml_format = previous_use_new_yaml_format
     end
@@ -605,7 +614,7 @@ describe Puppet::Graph::SimpleGraph do
             edge.keys.each { |x| expect(['source', 'target', 'callback', 'event']).to include(x) }
             %w{source target callback event}.collect { |x| edge[x] }
           end
-          expect(Set.new(actual_edge_tuples)).to eq(Set.new(expected_edge_tuples))
+          expect(Set.new(actual_edge_tuples)).to eq(Set.new(expected_edge_tuples.map { |tuple| tuple.map {|e| e.nil? ? nil : e.to_s }}))
           expect(actual_edge_tuples.length).to eq(expected_edge_tuples.length)
 
           # Check vertices one by one.
@@ -615,15 +624,16 @@ describe Puppet::Graph::SimpleGraph do
             expect(Set.new(vertices.keys)).to eq(Set.new(graph.vertices))
             vertices.each do |key, value|
               expect(value.keys.sort).to eq(%w{adjacencies vertex})
-              expect(value['vertex']).to equal(key)
+              expect(value['vertex']).to eq(key)
               adjacencies = value['adjacencies']
               expect(adjacencies).to be_a(Hash)
-              expect(Set.new(adjacencies.keys)).to eq(Set.new([:in, :out]))
+              expect(Set.new(adjacencies.keys)).to eq(Set.new(['in', 'out']))
               [:in, :out].each do |direction|
-                expect(adjacencies[direction]).to be_a(Hash)
+                direction_hash = adjacencies[direction.to_s]
+                expect(direction_hash).to be_a(Hash)
                 expected_adjacent_vertices = Set.new(graph.adjacent(key, :direction => direction, :type => :vertices))
-                expect(Set.new(adjacencies[direction].keys)).to eq(expected_adjacent_vertices)
-                adjacencies[direction].each do |adj_key, adj_value|
+                expect(Set.new(direction_hash.keys)).to eq(expected_adjacent_vertices)
+                direction_hash.each do |adj_key, adj_value|
                   # Since we already checked edges, just check consistency
                   # with edges.
                   desired_source = direction == :in ? adj_key : key
@@ -631,8 +641,8 @@ describe Puppet::Graph::SimpleGraph do
                   expected_edges = edges.select do |edge|
                     edge['source'] == desired_source && edge['target'] == desired_target
                   end
-                  expect(adj_value).to be_a(Set)
-                  if object_ids(adj_value) != object_ids(expected_edges)
+                  expect(adj_value).to be_a(Array)
+                  if adj_value != expected_edges
                     raise "For vertex #{key.inspect}, direction #{direction.inspect}: expected adjacencies #{expected_edges.inspect} but got #{adj_value.inspect}"
                   end
                 end
@@ -679,37 +689,30 @@ describe Puppet::Graph::SimpleGraph do
           # the internal representation of the graph is about to change.
         end
       end
-
-      it "should be able to serialize a graph where the vertices contain backreferences to the graph (#{which_format} format)" do
-        reference_graph = Puppet::Graph::SimpleGraph.new
-        vertex = Object.new
-        vertex.instance_eval { @graph = reference_graph }
-        reference_graph.add_edge(vertex, :other_vertex)
-        yaml_form = graph_to_yaml(reference_graph, which_format)
-        recovered_graph = YAML.load(yaml_form)
-
-        expect(recovered_graph.vertices.length).to eq(2)
-        recovered_vertex = recovered_graph.vertices.reject { |x| x.is_a?(Symbol) }[0]
-        expect(recovered_vertex.instance_eval { @graph }).to equal(recovered_graph)
-        expect(recovered_graph.edges.length).to eq(1)
-        recovered_edge = recovered_graph.edges[0]
-        expect(recovered_edge.source).to equal(recovered_vertex)
-        expect(recovered_edge.target).to eq(:other_vertex)
-      end
     end
 
     it "should serialize properly when used as a base class" do
       class Puppet::TestDerivedClass < Puppet::Graph::SimpleGraph
         attr_accessor :foo
+
+        def initialize_from_hash(hash)
+          super(hash)
+          @foo = hash['foo']
+        end
+
+        def to_data_hash
+          super.merge('foo' => @foo)
+        end
       end
       derived = Puppet::TestDerivedClass.new
-      derived.add_edge(:a, :b)
+      derived.add_edge('a', 'b')
       derived.foo = 1234
-      recovered_derived = YAML.load(YAML.dump(derived))
+      yaml = YAML.dump(derived)
+      recovered_derived = YAML.load(yaml)
       expect(recovered_derived.class).to equal(Puppet::TestDerivedClass)
       expect(recovered_derived.edges.length).to eq(1)
-      expect(recovered_derived.edges[0].source).to eq(:a)
-      expect(recovered_derived.edges[0].target).to eq(:b)
+      expect(recovered_derived.edges[0].source).to eq('a')
+      expect(recovered_derived.edges[0].target).to eq('b')
       expect(recovered_derived.vertices.length).to eq(2)
       expect(recovered_derived.foo).to eq(1234)
     end