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

data/spec/unit/node/facts_spec.rb

@@ -160,27 +160,27 @@ describe Puppet::Node::Facts, "when indirecting" do
       end
     end
 
-    describe "using pson" do
+    describe "using json" do
       before :each do
         @timestamp = Time.parse("Thu Oct 28 11:16:31 -0700 2010")
         @expiration = Time.parse("Thu Oct 28 11:21:31 -0700 2010")
       end
 
-      it "should accept properly formatted pson" do
-        pson = %Q({"name": "foo", "expiration": "#{@expiration}", "timestamp": "#{@timestamp}", "values": {"a": "1", "b": "2", "c": "3"}})
-        format = Puppet::Network::FormatHandler.format('pson')
-        facts = format.intern(Puppet::Node::Facts,pson)
+      it "should accept properly formatted json" do
+        json = %Q({"name": "foo", "expiration": "#{@expiration}", "timestamp": "#{@timestamp}", "values": {"a": "1", "b": "2", "c": "3"}})
+        format = Puppet::Network::FormatHandler.format('json')
+        facts = format.intern(Puppet::Node::Facts, json)
         expect(facts.name).to eq('foo')
         expect(facts.expiration).to eq(@expiration)
         expect(facts.timestamp).to eq(@timestamp)
         expect(facts.values).to eq({'a' => '1', 'b' => '2', 'c' => '3'})
       end
 
-      it "should generate properly formatted pson" do
+      it "should generate properly formatted json" do
         Time.stubs(:now).returns(@timestamp)
         facts = Puppet::Node::Facts.new("foo", {'a' => 1, 'b' => 2, 'c' => 3})
         facts.expiration = @expiration
-        result = PSON.parse(facts.to_pson)
+        result = JSON.parse(facts.to_json)
         expect(result['name']).to eq(facts.name)
         expect(result['values']).to eq(facts.values)
         expect(result['timestamp']).to eq(facts.timestamp.iso8601(9))
@@ -192,19 +192,19 @@ describe Puppet::Node::Facts, "when indirecting" do
         facts = Puppet::Node::Facts.new("foo", {'a' => 1, 'b' => 2, 'c' => 3})
         facts.expiration = @expiration
 
-        expect(facts.to_pson).to validate_against('api/schemas/facts.json')
+        expect(facts.to_json).to validate_against('api/schemas/facts.json')
       end
 
       it "should not include nil values" do
         facts = Puppet::Node::Facts.new("foo", {'a' => 1, 'b' => 2, 'c' => 3})
-        pson = PSON.parse(facts.to_pson)
-        expect(pson).not_to be_include("expiration")
+        json= JSON.parse(facts.to_json)
+        expect(json).not_to be_include("expiration")
       end
 
       it "should be able to handle nil values" do
-        pson = %Q({"name": "foo", "values": {"a": "1", "b": "2", "c": "3"}})
-        format = Puppet::Network::FormatHandler.format('pson')
-        facts = format.intern(Puppet::Node::Facts,pson)
+        json = %Q({"name": "foo", "values": {"a": "1", "b": "2", "c": "3"}})
+        format = Puppet::Network::FormatHandler.format('json')
+        facts = format.intern(Puppet::Node::Facts, json)
         expect(facts.name).to eq('foo')
         expect(facts.expiration).to be_nil
       end

data/spec/unit/node_spec.rb

@@ -55,14 +55,14 @@ describe Puppet::Node do
       end
     end
 
-    it "can round-trip through pson" do
+    it "can round-trip through json" do
       facts = Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
       node = Puppet::Node.new("hello",
                               :environment => 'bar',
                               :classes => ['erth', 'aiu'],
                               :parameters => {"hostname"=>"food"}
                              )
-      new_node = Puppet::Node.convert_from('pson', node.render('pson'))
+      new_node = Puppet::Node.convert_from('json', node.render('json'))
       expect(new_node.environment).to eq(node.environment)
       expect(new_node.parameters).to eq(node.parameters)
       expect(new_node.classes).to eq(node.classes)
@@ -76,7 +76,7 @@ describe Puppet::Node do
                               :classes => ['erth', 'aiu'],
                               :parameters => {"hostname"=>"food"}
                              )
-      expect(node.to_pson).to validate_against('api/schemas/node.json')
+      expect(node.to_json).to validate_against('api/schemas/node.json')
     end
 
     it "when missing optional parameters validates against the node json schema", :unless => Puppet.features.microsoft_windows? do
@@ -84,7 +84,7 @@ describe Puppet::Node do
       node = Puppet::Node.new("hello",
                               :environment => 'bar'
                              )
-      expect(node.to_pson).to validate_against('api/schemas/node.json')
+      expect(node.to_json).to validate_against('api/schemas/node.json')
     end
 
     it "should allow its environment parameter to be set by attribute after initialization" do
@@ -94,6 +94,15 @@ describe Puppet::Node do
       expect(node.environment_name).to eq(:bar)
       expect(node.parameters['environment']).to eq('bar')
     end
+
+    it 'to_data_hash returns value that is instance of to Data' do
+      node = Puppet::Node.new("hello",
+        :environment => 'bar',
+        :classes => ['erth', 'aiu'],
+        :parameters => {"hostname"=>"food"}
+      )
+      expect(Puppet::Pops::Types::TypeFactory.data.instance?(node.to_data_hash)).to be_truthy
+    end
   end
 
   describe "when serializing using yaml" do
@@ -159,7 +168,7 @@ describe Puppet::Node do
   describe "when converting from json" do
     before do
       @node = Puppet::Node.new("mynode")
-      @format = Puppet::Network::FormatHandler.format('pson')
+      @format = Puppet::Network::FormatHandler.format('json')
     end
 
     def from_json(json)
@@ -167,22 +176,22 @@ describe Puppet::Node do
     end
 
     it "sets its name" do
-      expect(Puppet::Node).to read_json_attribute('name').from(@node.to_pson).as("mynode")
+      expect(Puppet::Node).to read_json_attribute('name').from(@node.to_json).as("mynode")
     end
 
     it "includes the classes if set" do
       @node.classes = %w{a b c}
-      expect(Puppet::Node).to read_json_attribute('classes').from(@node.to_pson).as(%w{a b c})
+      expect(Puppet::Node).to read_json_attribute('classes').from(@node.to_json).as(%w{a b c})
     end
 
     it "includes parameters if set" do
       @node.parameters = {"a" => "b", "c" => "d"}
-      expect(Puppet::Node).to read_json_attribute('parameters').from(@node.to_pson).as({"a" => "b", "c" => "d"})
+      expect(Puppet::Node).to read_json_attribute('parameters').from(@node.to_json).as({"a" => "b", "c" => "d"})
     end
 
-    it "deserializes environment to environment_name as a string" do
+    it "deserializes environment to environment_name as a symbol" do
       @node.environment = environment
-      expect(Puppet::Node).to read_json_attribute('environment_name').from(@node.to_pson).as('bar')
+      expect(Puppet::Node).to read_json_attribute('environment_name').from(@node.to_json).as(:bar)
     end
   end
 end
@@ -237,6 +246,20 @@ describe Puppet::Node, "when merging facts" do
     Puppet::Node::Facts.indirection.save(Puppet::Node::Facts.new(@node.name, "one" => "c", "two" => "b"))
   end
 
+  context "when supplied facts as a parameter" do
+    let(:facts) { Puppet::Node::Facts.new(@node.name, "foo" => "bar") }
+
+    it "accepts facts to merge with the node" do
+      @node.expects(:merge).with({ 'foo' => 'bar' })
+      @node.fact_merge(facts)
+    end
+
+    it "will not query the facts indirection if facts are supplied" do
+      Puppet::Node::Facts.indirection.expects(:find).never
+      @node.fact_merge(facts)
+    end
+  end
+
   it "recovers with a Puppet::Error if something is thrown from the facts indirection" do
     Puppet::Node::Facts.indirection.expects(:find).raises "something bad happened in the indirector"
     expect { @node.fact_merge }.to raise_error(Puppet::Error, /Could not retrieve facts for testnode: something bad happened in the indirector/)

data/spec/unit/parameter_spec.rb

@@ -161,7 +161,7 @@ describe Puppet::Parameter do
     end
 
     it 'should format numbers appropriately' do
-      expect(described_class.format_value_for_display(1)).to eq("'1'")
+      expect(described_class.format_value_for_display(1)).to eq('1')
     end
 
     it 'should format symbols appropriately' do
@@ -169,25 +169,93 @@ describe Puppet::Parameter do
     end
 
     it 'should format arrays appropriately' do
-      expect(described_class.format_value_for_display([1, 'foo', :bar])).to eq("['1', 'foo', 'bar']")
+      expect(described_class.format_value_for_display([1, 'foo', :bar])).to eq("[1, 'foo', 'bar']")
     end
 
     it 'should format hashes appropriately' do
       expect(described_class.format_value_for_display(
         {1 => 'foo', :bar => 2, 'baz' => :qux}
-      )).to eq("{'1' => 'foo', 'bar' => '2', 'baz' => 'qux'}")
+      )).to eq(<<-RUBY.unindent.sub(/\n$/, ''))
+        {
+          1 => 'foo',
+          'bar' => 2,
+          'baz' => 'qux'
+        }
+      RUBY
     end
 
     it 'should format arrays with nested data appropriately' do
       expect(described_class.format_value_for_display(
         [1, 'foo', :bar, [1, 2, 3], {1 => 2, 3 => 4}]
-      )).to eq("['1', 'foo', 'bar', ['1', '2', '3'], {'1' => '2', '3' => '4'}]")
+      )).to eq(<<-RUBY.unindent.sub(/\n$/, ''))
+        [1, 'foo', 'bar',
+          [1, 2, 3],
+          {
+            1 => 2,
+            3 => 4
+          }]
+      RUBY
     end
 
     it 'should format hashes with nested data appropriately' do
       expect(described_class.format_value_for_display(
         {1 => 'foo', :bar => [2, 3, 4], 'baz' => {:qux => 1, :quux => 'two'}}
-      )).to eq("{'1' => 'foo', 'bar' => ['2', '3', '4'], 'baz' => {'quux' => 'two', 'qux' => '1'}}")
+      )).to eq(<<-RUBY.unindent.sub(/\n$/, ''))
+        {
+          1 => 'foo',
+          'bar' => [2, 3, 4],
+          'baz' => {
+            'qux' => 1,
+            'quux' => 'two'
+          }
+        }
+       RUBY
+    end
+
+    it 'should format hashes with nested Objects appropriately' do
+      tf = Puppet::Pops::Types::TypeFactory
+      type = tf.object({'name' => 'MyType', 'attributes' => { 'qux' => tf.integer, 'quux' => tf.string }})
+      expect(described_class.format_value_for_display(
+        {1 => 'foo', 'bar' => type.create(1, 'one'), 'baz' => type.create(2, 'two')}
+      )).to eq(<<-RUBY.unindent.sub(/\n$/, ''))
+        {
+          1 => 'foo',
+          'bar' => MyType({
+            'qux' => 1,
+            'quux' => 'one'
+          }),
+          'baz' => MyType({
+            'qux' => 2,
+            'quux' => 'two'
+          })
+        }
+      RUBY
+    end
+
+    it 'should format Objects with nested Objects appropriately' do
+      tf = Puppet::Pops::Types::TypeFactory
+      inner_type = tf.object({'name' => 'MyInnerType', 'attributes' => { 'qux' => tf.integer, 'quux' => tf.string }})
+      outer_type = tf.object({'name' => 'MyOuterType', 'attributes' => { 'x' => tf.string, 'inner' => inner_type }})
+      expect(described_class.format_value_for_display(
+        {'bar' => outer_type.create('a', inner_type.create(1, 'one')), 'baz' => outer_type.create('b', inner_type.create(2, 'two'))}
+      )).to eq(<<-RUBY.unindent.sub(/\n$/, ''))
+        {
+          'bar' => MyOuterType({
+            'x' => 'a',
+            'inner' => MyInnerType({
+              'qux' => 1,
+              'quux' => 'one'
+            })
+          }),
+          'baz' => MyOuterType({
+            'x' => 'b',
+            'inner' => MyInnerType({
+              'qux' => 2,
+              'quux' => 'two'
+            })
+          })
+        }
+      RUBY
     end
   end
 

data/spec/unit/parser/ast/leaf_spec.rb

@@ -60,12 +60,13 @@ describe Puppet::Parser::AST::Regex do
     end
   end
 
-  it 'should return the PRegexpType#regexp_to_s_with_delimiters with to_s' do
+  it "should return the regex source with to_s" do
     regex = stub 'regex'
     Regexp.stubs(:new).returns(regex)
 
-    val = Puppet::Parser::AST::Regex.new :value => '/ab/'
-    Puppet::Pops::Types::PRegexpType.expects(:regexp_to_s_with_delimiters)
+    val = Puppet::Parser::AST::Regex.new :value => "/ab/"
+
+    regex.expects(:source)
 
     val.to_s
   end

data/spec/unit/parser/compiler_spec.rb

@@ -11,7 +11,7 @@ class CompilerTestResource
   end
 
   def [](attr)
-    return nil if attr == :stage
+    return nil if (attr == :stage || attr == :alias)
     :main
   end
 

data/spec/unit/parser/environment_compiler_spec.rb

@@ -16,7 +16,6 @@ describe "Application instantiation" do
   end
 
   around :each do |example|
-    Puppet[:app_management] = true
     Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
     Puppet::Parser::EnvironmentCompiler.any_instance.stubs(:loaders).returns(loaders)
     Puppet.override(:loaders => loaders, :current_environment => env) do
@@ -27,7 +26,6 @@ describe "Application instantiation" do
       example.run
       Puppet::Type.rmtype(:cap)
     end
-    Puppet[:app_management] = false
   end
 
   MANIFEST = <<-EOS

data/spec/unit/parser/functions/sprintf_spec.rb

@@ -44,30 +44,4 @@ describe "the sprintf function" do
     expect(result).to(eql("<overlong:  027   0XBEEF (foo     )>"))
   end
 
-  it 'does not attempt to mutate its arguments' do
-    args = ['%d', 1].freeze
-    expect { @scope.function_sprintf(args) }.to_not raise_error
-  end
-
-  it 'support named arguments in a hash with string keys' do
-    result = @scope.function_sprintf(["%<foo>d : %<bar>f", {'foo' => 1, 'bar' => 2}])
-    expect(result).to eq("1 : 2.000000")
-  end
-
-  it 'raises a key error if a key is not present' do
-    expect do
-      @scope.function_sprintf(["%<foo>d : %<zanzibar>f", {'foo' => 1, 'bar' => 2}])
-    end.to raise_error(KeyError, /key<zanzibar> not found/)
-  end
-
-  it 'a hash with string keys that is output formats as strings' do
-    result = @scope.function_sprintf(["%s", {'foo' => 1, 'bar' => 2}])
-    expect(result).to eq("{\"foo\"=>1, \"bar\"=>2}")
-  end
-
-  it 'named arguments hash with non string keys are tolerated' do
-    result = @scope.function_sprintf(["%<foo>d : %<bar>f", {'foo' => 1, 'bar' => 2, 1 => 2, [1] => 2, false => true, {} => {}}])
-    expect(result).to eq("1 : 2.000000")
-  end
-
 end

data/spec/unit/parser/resource_spec.rb

@@ -49,8 +49,9 @@ describe Puppet::Parser::Resource do
   end
 
   it "should get its environment from its scope" do
-    scope = stub 'scope', :source => stub("source"), :namespaces => nil
+    scope = stub 'scope', :source => stub("source")
     scope.expects(:environment).returns("foo").at_least_once
+    scope.expects(:lookupdefaults).returns({})
     expect(Puppet::Parser::Resource.new("file", "whatever", :scope => scope).environment).to eq("foo")
   end
 
@@ -260,43 +261,104 @@ describe Puppet::Parser::Resource do
 
       expect(@compiler.catalog).to be_edge(main, resource)
     end
-  end
 
-  describe "when finishing" do
-    before do
-      @resource = Puppet::Parser::Resource.new("file", "whatever", :scope => @scope, :source => @source)
-    end
+    it 'should assign default value to generated resource' do
+      Puppet[:code] = <<-PUPPET
+        define one($var) {
+          notify { "${var} says hello": }
+        }
+        
+        define two($x = $title) {
+          One {
+            var => $x
+          }
+          one { a: }
+          one { b: var => 'bill'}
+        }
+        two { 'bob': }
+      PUPPET
 
-    it "should do nothing if it has already been finished" do
-      @resource.finish
-      @resource.expects(:add_defaults).never
-      @resource.finish
+      catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new 'anyone')
+      edges = catalog.edges.map {|e| [e.source.ref, e.target.ref]}
+
+      expect(edges).to include(['One[a]', 'Notify[bob says hello]'])
+      expect(edges).to include(['One[b]', 'Notify[bill says hello]'])
+    end
+
+    it 'should override default value with new value' do
+      Puppet[:code] = <<-PUPPET.unindent
+        class foo {
+          File {
+            ensure => file,
+            mode   => '644',
+            owner  => 'root',
+            group  => 'root',
+          }
+        
+          file { '/tmp/foo':
+            ensure  => directory
+          }
+        
+          File['/tmp/foo'] { mode => '0755' }
+        }
+        include foo
+        PUPPET
+
+      catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new 'anyone')
+      file = catalog.resource('File[/tmp/foo]')
+      expect(file).to be_a(Puppet::Resource)
+      expect(file['mode']).to eql('0755')
     end
+  end
 
-    it "should add all defaults available from the scope" do
-      @resource.scope.expects(:lookupdefaults).with(@resource.type).returns(:owner => param(:owner, "default", @resource.source))
-      @resource.finish
+  describe 'when evaluating resource defaults' do
+    let(:resource) { Puppet::Parser::Resource.new('file', 'whatever', :scope => @scope, :source => @source) }
+
+    it 'should add all defaults available from the scope' do
+      @scope.expects(:lookupdefaults).with('File').returns(:owner => param(:owner, 'default', @source))
 
-      expect(@resource[:owner]).to eq("default")
+      expect(resource[:owner]).to eq('default')
     end
 
-    it "should not replace existing parameters with defaults" do
-      @resource.set_parameter :owner, "oldvalue"
-      @resource.scope.expects(:lookupdefaults).with(@resource.type).returns(:owner => :replaced)
-      @resource.finish
+    it 'should not replace existing parameters with defaults' do
+      @scope.expects(:lookupdefaults).with('File').returns(:owner => param(:owner, 'replaced', @source))
+      r = Puppet::Parser::Resource.new('file', 'whatever', :scope => @scope, :source => @source, :parameters => [ param(:owner, 'oldvalue', @source) ])
+      expect(r[:owner]).to eq('oldvalue')
+    end
+
+    it 'should override defaults with new parameters' do
+      @scope.expects(:lookupdefaults).with('File').returns(:owner => param(:owner, 'replaced', @source))
 
-      expect(@resource[:owner]).to eq("oldvalue")
+      resource.set_parameter(:owner, 'newvalue')
+      expect(resource[:owner]).to eq('newvalue')
     end
 
-    it "should add a copy of each default, rather than the actual default parameter instance" do
-      newparam = param(:owner, "default", @resource.source)
+    it 'should add a copy of each default, rather than the actual default parameter instance' do
+      newparam = param(:owner, 'default', @source)
       other = newparam.dup
       other.value = "other"
       newparam.expects(:dup).returns(other)
-      @resource.scope.expects(:lookupdefaults).with(@resource.type).returns(:owner => newparam)
-      @resource.finish
+      @scope.expects(:lookupdefaults).with('File').returns(:owner => newparam)
+
+      expect(resource[:owner]).to eq('other')
+    end
+
+    it "should tag with value of default parameter named 'tag'" do
+      @scope.expects(:lookupdefaults).with('File').returns(:tag => param(:tag, 'the_tag', @source))
+
+      expect(resource.tags).to include('the_tag')
+    end
+  end
 
-      expect(@resource[:owner]).to eq("other")
+  describe "when finishing" do
+    before do
+      @resource = Puppet::Parser::Resource.new("file", "whatever", :scope => @scope, :source => @source)
+    end
+
+    it "should do nothing if it has already been finished" do
+      @resource.finish
+      @resource.expects(:add_scope_tags).never
+      @resource.finish
     end
 
     it "converts parameters with Sensitive values to unwrapped values and metadata" do