puppet 4.10.12-x86-mingw32 → 5.0.0-x86-mingw32

data/spec/unit/file_serving/http_metadata_spec.rb

@@ -61,7 +61,7 @@ describe Puppet::FileServing::HttpMetadata do
         metadata = described_class.new(http_response)
         metadata.collect
         expect( metadata.checksum_type ).to eq :mtime
-        expect( metadata.checksum ).to eq "{mtime}#{time.to_time}"
+        expect( metadata.checksum ).to eq "{mtime}#{time.to_time.utc}"
       end
     end
 

data/spec/unit/file_serving/metadata_spec.rb

@@ -18,8 +18,13 @@ describe Puppet::FileServing::Metadata do
     expect(Puppet::FileServing::Metadata.new(foobar)).to respond_to(:collect)
   end
 
-  it "should support pson serialization" do
-    expect(Puppet::FileServing::Metadata.new(foobar)).to respond_to(:to_pson)
+  it "should default to json" do
+    expect(Puppet::FileServing::Metadata.default_format).to eq(:json)
+  end
+
+  it "should support json, pson, yaml" do
+    # msgpack is optional, so using include instead of eq
+    expect(Puppet::FileServing::Metadata.supported_formats).to include(:json, :pson, :yaml)
   end
 
   it "should support deserialization" do
@@ -41,8 +46,8 @@ describe Puppet::FileServing::Metadata do
       expect(metadata.to_data_hash['relative_path']).to eq(metadata.relative_path)
     end
 
-    it "should pass the links in the hash verbatim" do
-      expect(metadata.to_data_hash['links']).to eq(metadata.links)
+    it "should pass the links in the hash as a string" do
+      expect(metadata.to_data_hash['links']).to eq(metadata.links.to_s)
     end
 
     it "should pass the path owner in the hash verbatim" do
@@ -193,7 +198,7 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
         end
 
         it "should validate against the schema" do
-          expect(metadata.to_pson).to validate_against('api/schemas/file_metadata.json')
+          expect(metadata.to_json).to validate_against('api/schemas/file_metadata.json')
         end
 
         describe "when a source and content_uri are set" do
@@ -203,7 +208,7 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
           end
 
           it "should validate against the schema" do
-            expect(metadata.to_pson).to validate_against('api/schemas/file_metadata.json')
+            expect(metadata.to_json).to validate_against('api/schemas/file_metadata.json')
           end
         end
       end
@@ -230,7 +235,7 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
 
         it "should validate against the schema" do
           metadata.collect
-          expect(metadata.to_pson).to validate_against('api/schemas/file_metadata.json')
+          expect(metadata.to_json).to validate_against('api/schemas/file_metadata.json')
         end
       end
     end
@@ -299,7 +304,7 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
         end
 
         it "should validate against the schema" do
-          expect(metadata.to_pson).to validate_against('api/schemas/file_metadata.json')
+          expect(metadata.to_json).to validate_against('api/schemas/file_metadata.json')
         end
       end
     end
@@ -333,7 +338,7 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
       end
 
       it "should validate against the schema" do
-        expect(metadata.to_pson).to validate_against('api/schemas/file_metadata.json')
+        expect(metadata.to_json).to validate_against('api/schemas/file_metadata.json')
       end
     end
   end

data/spec/unit/forge/forge_spec.rb

@@ -62,7 +62,7 @@ describe Puppet::Forge do
 
         # ignores Puppet::Forge::Repository#read_response, provides response to fetch
         performs_an_http_request(ok_response) do |http|
-          encoded_uri = "/v3/releases?module=#{module_name}&sort_by=version&module_groups=base%20pe"
+          encoded_uri = "/v3/releases?module=#{module_name}&module_groups=base%20pe"
           http.expects(:request).with(responds_with(:path, encoded_uri))
         end
 
@@ -74,7 +74,7 @@ describe Puppet::Forge do
 
         # ignores Puppet::Forge::Repository#read_response, provides response to fetch
         performs_an_http_request(ok_response) do |http|
-          encoded_uri = "/v3/releases?module=puppetlabs-#{mixed_utf8_query_param_encoded}&sort_by=version"
+          encoded_uri = "/v3/releases?module=puppetlabs-#{mixed_utf8_query_param_encoded}"
           http.expects(:request).with(responds_with(:path, encoded_uri))
         end
 

data/spec/unit/forge_spec.rb

@@ -131,111 +131,6 @@ describe Puppet::Forge do
     end
   end
 
-  # See PUP-8008
-  context "when multiple module_groups are defined" do
-    let(:release_response) do
-      releases = JSON.parse(http_response)
-      releases['results'] = []
-      JSON.dump(releases)
-    end
-
-    context "with space seperator" do
-      before :each do
-        repository_responds_with(stub(:body => release_response, :code => '200')).with {|uri| uri =~ /module_groups=foo bar/}
-        Puppet[:module_groups] = "foo bar"
-      end
-
-      it "passes module_groups with search" do
-        forge.search('bacula')
-      end
-
-      it "passes module_groups with fetch" do
-        forge.fetch('puppetlabs-bacula')
-      end
-    end
-
-    context "with plus seperator" do
-      before :each do
-        repository_responds_with(stub(:body => release_response, :code => '200')).with {|uri| uri =~ /module_groups=foo bar/}
-        Puppet[:module_groups] = "foo+bar"
-      end
-
-      it "passes module_groups with search" do
-        forge.search('bacula')
-      end
-
-      it "passes module_groups with fetch" do
-        forge.fetch('puppetlabs-bacula')
-      end
-    end
-
-    # See PUP-8008
-    context "when there are multiple pages of results" do
-      before(:each) do
-        Puppet::Forge::Repository.any_instance.expects(:make_http_request).with {|uri| uri =~ /module_groups=foo bar/ && uri !=~ /offset/ }.returns(stub(:body => first_page, :code => '200'))
-
-        # Request for second page should not have module_groups already encoded
-        Puppet::Forge::Repository.any_instance.expects(:make_http_request).with {|uri| uri =~ /module_groups=foo bar/ && uri =~ /offset=1/ }.returns(stub(:body => last_page, :code => '200'))
-      end
-
-      context "with space seperator" do
-        before(:each) do
-          Puppet[:module_groups] = "foo bar"
-        end
-
-        let(:first_page) do
-          resp = JSON.parse(http_response)
-          resp['results'] = []
-          resp['pagination']['next'] = "/v3/modules?limit=1&offset=1&module_groups=foo%20bar"
-          JSON.dump(resp)
-        end
-
-        let(:last_page) do
-          resp = JSON.parse(http_response)
-          resp['results'] = []
-          resp['pagination']['current'] = "/v3/modules?limit=1&offset=1&module_groups=foo%20bar"
-          JSON.dump(resp)
-        end
-
-        it "traverses pages during search" do
-          forge.search('bacula')
-        end
-
-        it "traverses pages during fetch" do
-          forge.fetch('puppetlabs-bacula')
-        end
-      end
-
-      context "with plus seperator" do
-        before(:each) do
-          Puppet[:module_groups] = "foo+bar"
-        end
-
-        let(:first_page) do
-          resp = JSON.parse(http_response)
-          resp['results'] = []
-          resp['pagination']['next'] = "/v3/modules?limit=1&offset=1&module_groups=foo+bar"
-          JSON.dump(resp)
-        end
-
-        let(:last_page) do
-          resp = JSON.parse(http_response)
-          resp['results'] = []
-          resp['pagination']['current'] = "/v3/modules?limit=1&offset=1&module_groups=foo+bar"
-          JSON.dump(resp)
-        end
-
-        it "traverses pages during search" do
-          forge.search('bacula')
-        end
-
-        it "traverses pages during fetch" do
-          forge.fetch('puppetlabs-bacula')
-        end
-      end
-    end
-  end
-
   context "when the connection to the forge fails" do
     before :each do
       repository_responds_with(stub(:body => '{}', :code => '404', :message => "not found"))

data/spec/unit/functions/annotate_spec.rb

@@ -0,0 +1,175 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet_spec/compiler'
+
+describe 'the annotate function' do
+  include PuppetSpec::Compiler
+
+  let(:annotation) { <<-PUPPET }
+    type MyAdapter = Object[{
+      parent => Annotation,
+      attributes => {
+        id => Integer,
+        value => String[1]
+      }
+    }]
+  PUPPET
+
+  let(:annotation2) { <<-PUPPET }
+    type MyAdapter2 = Object[{
+      parent => Annotation,
+      attributes => {
+        id => Integer,
+        value => String[1]
+      }
+    }]
+  PUPPET
+
+  context 'with object and hash arguments' do
+    it 'creates new annotation on object' do
+      code = <<-PUPPET
+        #{annotation}
+        type MyObject = Object[{
+        }]
+        $my_object = MyObject({})
+        MyAdapter.annotate($my_object, { 'id' => 2, 'value' => 'annotation value' })
+        notice(MyAdapter.annotate($my_object).value)
+      PUPPET
+      expect(eval_and_collect_notices(code)).to eql(['annotation value'])
+    end
+
+    it 'forces creation of new annotation' do
+      code = <<-PUPPET
+      #{annotation}
+      type MyObject = Object[{
+      }]
+      $my_object = MyObject({})
+      MyAdapter.annotate($my_object, { 'id' => 2, 'value' => 'annotation value' })
+      notice(MyAdapter.annotate($my_object).value)
+      MyAdapter.annotate($my_object, { 'id' => 2, 'value' => 'annotation value 2' })
+      notice(MyAdapter.annotate($my_object).value)
+      PUPPET
+      expect(eval_and_collect_notices(code)).to eql(['annotation value', 'annotation value 2'])
+    end
+  end
+
+  context 'with object and block arguments' do
+    it 'creates new annotation on object' do
+      code = <<-PUPPET
+        #{annotation}
+        type MyObject = Object[{
+        }]
+        $my_object = MyObject({})
+        MyAdapter.annotate($my_object) || { { 'id' => 2, 'value' => 'annotation value' } }
+        notice(MyAdapter.annotate($my_object).value)
+      PUPPET
+      expect(eval_and_collect_notices(code)).to eql(['annotation value'])
+    end
+
+    it 'does not recreate annotation' do
+      code = <<-PUPPET
+      #{annotation}
+      type MyObject = Object[{
+      }]
+      $my_object = MyObject({})
+      MyAdapter.annotate($my_object) || {
+        notice('should call this');
+        { 'id' => 2, 'value' => 'annotation value' }
+      }
+      MyAdapter.annotate($my_object) || {
+        notice('should not call this');
+        { 'id' => 2, 'value' => 'annotation value 2' }
+      }
+      notice(MyAdapter.annotate($my_object).value)
+      PUPPET
+      expect(eval_and_collect_notices(code)).to eql(['should call this', 'annotation value'])
+    end
+  end
+
+  it "with object and 'clear' arguments, clears and returns annotation" do
+    code = <<-PUPPET
+      #{annotation}
+      type MyObject = Object[{
+      }]
+      $my_object = MyObject({})
+      MyAdapter.annotate($my_object, { 'id' => 2, 'value' => 'annotation value' })
+      notice(MyAdapter.annotate($my_object, clear).value)
+      notice(MyAdapter.annotate($my_object) == undef)
+    PUPPET
+    expect(eval_and_collect_notices(code)).to eql(['annotation value', 'true'])
+  end
+
+  context 'when object is an annotated Type' do
+    it 'finds annotation declared in the type' do
+      code = <<-PUPPET
+        #{annotation}
+        type MyObject = Object[{
+          annotations => {
+            MyAdapter => { 'id' => 2, 'value' => 'annotation value' }
+          }
+        }]
+        notice(MyAdapter.annotate(MyObject).value)
+      PUPPET
+      expect(eval_and_collect_notices(code)).to eql(['annotation value'])
+    end
+
+    it 'fails attempts to clear a declared annotation' do
+      code = <<-PUPPET
+        #{annotation}
+        type MyObject = Object[{
+          annotations => {
+            MyAdapter => { 'id' => 2, 'value' => 'annotation value' }
+          }
+        }]
+        notice(MyAdapter.annotate(MyObject).value)
+        notice(MyAdapter.annotate(MyObject, clear).value)
+      PUPPET
+      expect { eval_and_collect_notices(code) }.to raise_error(/attempt to clear MyAdapter annotation declared on MyObject/)
+    end
+
+    it 'fails attempts to redefine a declared annotation' do
+      code = <<-PUPPET
+        #{annotation}
+        type MyObject = Object[{
+          annotations => {
+            MyAdapter => { 'id' => 2, 'value' => 'annotation value' }
+          }
+        }]
+        notice(MyAdapter.annotate(MyObject).value)
+        notice(MyAdapter.annotate(MyObject, { 'id' => 3, 'value' => 'some other value' }).value)
+      PUPPET
+      expect { eval_and_collect_notices(code) }.to raise_error(/attempt to redefine MyAdapter annotation declared on MyObject/)
+    end
+
+    it 'allows annotation that are not declared in the type' do
+      code = <<-PUPPET
+        #{annotation}
+        #{annotation2}
+        type MyObject = Object[{
+          annotations => {
+            MyAdapter => { 'id' => 2, 'value' => 'annotation value' }
+          }
+        }]
+        notice(MyAdapter.annotate(MyObject).value)
+        notice(MyAdapter2.annotate(MyObject, { 'id' => 3, 'value' => 'some other value' }).value)
+      PUPPET
+      expect(eval_and_collect_notices(code)).to eql(['annotation value', 'some other value'])
+    end
+  end
+
+  it 'used on Pcore, can add multiple annotations an object' do
+    code = <<-PUPPET
+      #{annotation}
+      #{annotation2}
+      type MyObject = Object[{
+      }]
+      $my_object = Pcore.annotate(MyObject({}), {
+        MyAdapter => { 'id' => 2, 'value' => 'annotation value' },
+        MyAdapter2 => { 'id' => 3, 'value' => 'second annotation value' }
+      })
+      notice(MyAdapter.annotate($my_object).value)
+      notice(MyAdapter2.annotate($my_object).value)
+    PUPPET
+    expect(eval_and_collect_notices(code)).to eql(['annotation value', 'second annotation value'])
+  end
+end

data/spec/unit/functions/break_spec.rb

@@ -8,7 +8,7 @@ describe 'the break function' do
   include Matchers::Resource
 
   context  do
-    it 'breaks iteration as if at end of input in a map for an array' do
+    it 'breaks iteration as if at end of input in a map' do
       expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[[1, 2]]')
           function please_break() {
             [1,2,3].map |$x| { if $x == 3 { break() } $x }
@@ -17,16 +17,7 @@ describe 'the break function' do
         CODE
     end
 
-    it 'breaks iteration as if at end of input in a map for a hash' do
-      expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[[1, 2]]')
-          function please_break() {
-            {'a' => 1, 'b' => 2, 'c' => 3}.map |$x, $y| { if $y == 3 { break() } $y }
-          }
-          notify { String(please_break()): }
-        CODE
-    end
-
-    it 'breaks iteration as if at end of input in a reduce for an array' do
+    it 'breaks iteration as if at end of input in a reduce' do
       expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[6]')
           function please_break() {
             [1,2,3,4].reduce |$memo, $x| { if $x == 4 { break() } $memo + $x }
@@ -35,21 +26,7 @@ describe 'the break function' do
         CODE
     end
 
-    it 'breaks iteration as if at end of input in a reduce for a hash' do
-      expect(compile_to_catalog(<<-CODE)).to have_resource("Notify[['abc', 6]]")
-          function please_break() {
-            {'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4}.reduce |$memo, $x| {
-              if $x[1] == 4 { break() }
-              $string = "${memo[0]}${x[0]}"
-              $number = $memo[1] + $x[1]
-              [$string, $number]
-            }
-          }
-          notify { String(please_break()): }
-        CODE
-    end
-
-    it 'breaks iteration as if at end of input in an each for an array' do
+    it 'breaks iteration as if at end of input in an each' do
       expect(compile_to_catalog(<<-CODE)).to_not have_resource('Notify[3]')
           function please_break() {
             [1,2,3].each |$x| { if $x == 3 { break() } notify { "$x": } }
@@ -58,15 +35,6 @@ describe 'the break function' do
         CODE
     end
 
-    it 'breaks iteration as if at end of input in an each for a hash' do
-      expect(compile_to_catalog(<<-CODE)).to_not have_resource('Notify[3]')
-          function please_break() {
-            {'a' => 1, 'b' => 2, 'c' => 3}.each |$x, $y| { if $y == 3 { break() } notify { "$y": } }
-          }
-          please_break()
-        CODE
-    end
-
     it 'breaks iteration as if at end of input in a reverse_each' do
       expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[2]')
           function please_break() {
@@ -76,22 +44,24 @@ describe 'the break function' do
         CODE
     end
 
-    it 'does not provide early exit from a class' do
-      # A break would semantically mean that the class should not be included - as if the
-      # iteration over class names should stop. That is too magic and should
-      # be done differently by the user.
-      #
-      expect do
-        compile_to_catalog(<<-CODE)
-          class does_break {
-            notice 'a'
-            if 1 == 1 { break() } # avoid making next line statically unreachable
-            notice 'b'
-          }
-          include(does_break)
-        CODE
-      end.to raise_error(/break\(\) from context where this is illegal at unknown:3 on node.*/)
-    end
+  end
+
+  it 'does not provide early exit from a class' do
+    # A break would semantically mean that the class should not be included - as if the
+    # iteration over class names should stop. That is too magic and should
+    # be done differently by the user.
+    #
+    expect do
+      compile_to_catalog(<<-CODE)
+        class does_break {
+          notice 'a'
+          if 1 == 1 { break() } # avoid making next line statically unreachable
+          notice 'b'
+        }
+        include(does_break)
+      CODE
+    end.to raise_error(/break\(\) from context where this is illegal at unknown:3 on node.*/)
+  end
 
     it 'does not provide early exit from a define' do
       # A break would semantically mean that the resource should not be created - as if the
@@ -110,39 +80,38 @@ describe 'the break function' do
       end.to raise_error(/break\(\) from context where this is illegal at unknown:3 on node.*/)
     end
 
-    it 'can be called when nested in a function to make that function behave as a break' do
-      # This allows functions like break_when(...) to be implemented by calling break() conditionally
-      #
-      expect(eval_and_collect_notices(<<-CODE)).to eql(['[100]'])
-        function nested_break($x) {
-          if $x == 2 { break() } else { $x * 100 }
-        }
-        function example() {
-          [1,2,3].map |$x| { nested_break($x)  }
-        }
-        notice example()
-        CODE
-    end
+  it 'can be called when nested in a function to make that function behave as a break' do
+    # This allows functions like break_when(...) to be implemented by calling break() conditionally
+    #
+    expect(eval_and_collect_notices(<<-CODE)).to eql(['[100]'])
+      function nested_break($x) {
+        if $x == 2 { break() } else { $x * 100 }
+      }
+      function example() {
+        [1,2,3].map |$x| { nested_break($x)  }
+      }
+      notice example()
+      CODE
+  end
 
-    it 'can not be called nested from top scope' do
-      expect do
-        compile_to_catalog(<<-CODE)
-          # line 1
-          # line 2
-          $result = with(1) |$x| { with($x) |$x| {break() }}
-          notice $result
-        CODE
-      end.to raise_error(/break\(\) from context where this is illegal at unknown:3 on node.*/)
-    end
+  it 'can not be called nested from top scope' do
+    expect do
+      compile_to_catalog(<<-CODE)
+        # line 1
+        # line 2
+        $result = with(1) |$x| { with($x) |$x| {break() }}
+        notice $result
+      CODE
+    end.to raise_error(/break\(\) from context where this is illegal at unknown:3 on node.*/)
+  end
 
-    it 'can not be called from top scope' do
-      expect do
-        compile_to_catalog(<<-CODE)
-          # line 1
-          # line 2
-          break()
-        CODE
-      end.to raise_error(/break\(\) from context where this is illegal at unknown:3 on node.*/)
-    end
+  it 'can not be called from top scope' do
+    expect do
+      compile_to_catalog(<<-CODE)
+        # line 1
+        # line 2
+        break()
+      CODE
+    end.to raise_error(/break\(\) from context where this is illegal at unknown:3 on node.*/)
   end
 end