puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

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

@@ -67,6 +67,10 @@ describe 'The type factory' do
       Puppet::Pops::Types::TypeFactory.undef().class().should == Puppet::Pops::Types::PNilType
     end
 
+    it 'default() returns PDefaultType' do
+      Puppet::Pops::Types::TypeFactory.default().class().should == Puppet::Pops::Types::PDefaultType
+    end
+
     it 'range(to, from) returns PIntegerType' do
       t = Puppet::Pops::Types::TypeFactory.range(1,2)
       t.class().should == Puppet::Pops::Types::PIntegerType
@@ -150,10 +154,11 @@ describe 'The type factory' do
       ht.element_type.class.should == Puppet::Pops::Types::PDataType
     end
 
-    it 'ruby(1) returns PRubyType[\'Fixnum\']' do
+    it 'ruby(1) returns PRuntimeType[ruby, \'Fixnum\']' do
       ht = Puppet::Pops::Types::TypeFactory.ruby(1)
-      ht.class().should == Puppet::Pops::Types::PRubyType
-      ht.ruby_class.should == 'Fixnum'
+      ht.class().should == Puppet::Pops::Types::PRuntimeType
+      ht.runtime.should == :ruby
+      ht.runtime_type_name.should == 'Fixnum'
     end
 
     it 'a size constrained collection can be created from array' do

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

@@ -5,7 +5,8 @@ describe Puppet::Pops::Types::TypeParser do
   extend RSpec::Matchers::DSL
 
   let(:parser) { Puppet::Pops::Types::TypeParser.new }
-  let(:types) { Puppet::Pops::Types::TypeFactory }
+  let(:types)  { Puppet::Pops::Types::TypeFactory }
+
 
   it "rejects a puppet expression" do
     expect { parser.parse("1 + 1") }.to raise_error(Puppet::ParseError, /The expression <1 \+ 1> is not a valid type specification/)
@@ -30,7 +31,7 @@ describe Puppet::Pops::Types::TypeParser do
   end
 
   [
-    'Object', 'Data', 'CatalogEntry', 'Boolean', 'Scalar', 'Undef', 'Numeric',
+    'Any', 'Data', 'CatalogEntry', 'Boolean', 'Scalar', 'Undef', 'Numeric', 'Default'
   ].each do |name|
     it "does not support parameterizing unparameterized type <#{name}>" do
       expect { parser.parse("#{name}[Integer]") }.to raise_unparameterized_error_for(name)
@@ -38,7 +39,7 @@ describe Puppet::Pops::Types::TypeParser do
   end
 
   it "parses a simple, unparameterized type into the type object" do
-    expect(the_type_parsed_from(types.object)).to be_the_type(types.object)
+    expect(the_type_parsed_from(types.any)).to be_the_type(types.any)
     expect(the_type_parsed_from(types.integer)).to be_the_type(types.integer)
     expect(the_type_parsed_from(types.float)).to be_the_type(types.float)
     expect(the_type_parsed_from(types.string)).to be_the_type(types.string)
@@ -50,6 +51,7 @@ describe Puppet::Pops::Types::TypeParser do
     expect(the_type_parsed_from(types.tuple)).to be_the_type(types.tuple)
     expect(the_type_parsed_from(types.struct)).to be_the_type(types.struct)
     expect(the_type_parsed_from(types.optional)).to be_the_type(types.optional)
+    expect(the_type_parsed_from(types.default)).to be_the_type(types.default)
   end
 
   it "interprets an unparameterized Array as an Array of Data" do
@@ -113,6 +115,18 @@ describe Puppet::Pops::Types::TypeParser do
     expect(the_type_parsed_from(struct_t)).to be_the_type(struct_t)
   end
 
+  describe "handles parsing of patterns and regexp" do
+    { 'Pattern[/([a-z]+)([1-9]+)/]'        => [:pattern, [/([a-z]+)([1-9]+)/]],
+      'Pattern["([a-z]+)([1-9]+)"]'        => [:pattern, [/([a-z]+)([1-9]+)/]],
+      'Regexp[/([a-z]+)([1-9]+)/]'         => [:regexp,  [/([a-z]+)([1-9]+)/]],
+      'Pattern[/x9/, /([a-z]+)([1-9]+)/]'  => [:pattern, [/x9/, /([a-z]+)([1-9]+)/]],
+    }.each do |source, type|
+      it "such that the source '#{source}' yields the type #{type.to_s}" do
+        expect(parser.parse(source)).to be_the_type(Puppet::Pops::Types::TypeFactory.send(type[0], *type[1]))
+      end
+    end
+  end
+
   it "rejects an collection spec with the wrong number of parameters" do
     expect { parser.parse("Array[Integer, 1,2,3]") }.to raise_the_parameter_error("Array", "1 to 3", 4)
     expect { parser.parse("Hash[Integer, Integer, 1,2,3]") }.to raise_the_parameter_error("Hash", "1 to 4", 5)
@@ -159,7 +173,7 @@ describe Puppet::Pops::Types::TypeParser do
   end
 
   it 'parses a ruby type' do
-    expect(parser.parse("Ruby['Integer']")).to be_the_type(types.ruby_type('Integer'))
+    expect(parser.parse("Runtime[ruby, 'Integer']")).to be_the_type(types.ruby_type('Integer'))
   end
 
   it 'parses a callable type' do
@@ -178,12 +192,19 @@ describe Puppet::Pops::Types::TypeParser do
     expect(parser.parse("Callable[String, Callable[Boolean]]")).to be_the_type(types.callable(String, types.callable(true)))
   end
 
-  it 'parses a parameterized callable type with only min/max' do
+  it 'parses a parameterized callable type with 0 min/max' do
     t = parser.parse("Callable[0,0]")
     expect(t).to be_the_type(types.callable())
     expect(t.param_types.types).to be_empty
   end
 
+  it 'parses a parameterized callable type with >0 min/max' do
+    t = parser.parse("Callable[0,1]")
+    expect(t).to be_the_type(types.callable(0,1))
+    # Contains a Unit type to indicate "called with what you accept"
+    expect(t.param_types.types[0]).to be_the_type(Puppet::Pops::Types::PUnitType.new())
+  end
+
   matcher :be_the_type do |type|
     calc = Puppet::Pops::Types::TypeCalculator.new
 

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

@@ -6,12 +6,12 @@ require 'puppet_spec/pops'
 # relative to this spec file (./) does not work as this file is loaded by rspec
 require File.join(File.dirname(__FILE__), '../parser/parser_rspec_helper')
 
-describe "validating 3x" do
+describe "validating 4x" do
   include ParserRspecHelper
   include PuppetSpec::Pops
 
   let(:acceptor) { Puppet::Pops::Validation::Acceptor.new() }
-  let(:validator) { Puppet::Pops::Validation::ValidatorFactory_3_1.new().validator(acceptor) }
+  let(:validator) { Puppet::Pops::Validation::ValidatorFactory_4_0.new().validator(acceptor) }
 
   def validate(model)
     validator.validate(model)
@@ -25,44 +25,160 @@ describe "validating 3x" do
   end
 
   it 'should raise error for illegal variable names' do
-    pending "validation was too strict, now too relaxed - validation missing"
-    expect(validate(fqn('Aaa').var())).to have_issue(Puppet::Pops::Issues::ILLEGAL_NAME)
-    expect(validate(fqn('AAA').var())).to have_issue(Puppet::Pops::Issues::ILLEGAL_NAME)
+    expect(validate(fqn('Aaa').var())).to have_issue(Puppet::Pops::Issues::ILLEGAL_VAR_NAME)
+    expect(validate(fqn('AAA').var())).to have_issue(Puppet::Pops::Issues::ILLEGAL_VAR_NAME)
+    expect(validate(fqn('aaa::_aaa').var())).to have_issue(Puppet::Pops::Issues::ILLEGAL_VAR_NAME)
   end
 
-  it 'should raise error for -= assignment' do
-    expect(validate(fqn('aaa').minus_set(2))).to have_issue(Puppet::Pops::Issues::UNSUPPORTED_OPERATOR)
+  it 'should not raise error for variable name with underscore first in first name segment' do
+    expect(validate(fqn('_aa').var())).to_not have_issue(Puppet::Pops::Issues::ILLEGAL_VAR_NAME)
+    expect(validate(fqn('::_aa').var())).to_not have_issue(Puppet::Pops::Issues::ILLEGAL_VAR_NAME)
   end
 
-end
+  context 'for non productive expressions' do
+    [ '1',
+      '3.14',
+      "'a'",
+      '"a"',
+      '"${$a=10}"', # interpolation with side effect
+      'false',
+      'true',
+      'default',
+      'undef',
+      '[1,2,3]',
+      '{a=>10}',
+      'if 1 {2}',
+      'if 1 {2} else {3}',
+      'if 1 {2} elsif 3 {4}',
+      'unless 1 {2}',
+      'unless 1 {2} else {3}',
+      '1 ? 2 => 3',
+      '1 ? { 2 => 3}',
+      '-1',
+      '-foo()', # unary minus on productive
+      '1+2',
+      '1<2',
+      '(1<2)',
+      '!true',
+      '!foo()', # not on productive
+      '$a',
+      '$a[1]',
+      'name',
+      'Type',
+      'Type[foo]'
+      ].each do |expr|
+      it "produces error for non productive: #{expr}" do
+        source = "#{expr}; $a = 10"
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::IDEM_EXPRESSION_NOT_LAST)
+      end
 
-describe "validating 4x" do
-  include ParserRspecHelper
-  include PuppetSpec::Pops
+      it "does not produce error when last for non productive: #{expr}" do
+        source = " $a = 10; #{expr}"
+        expect(validate(parse(source))).to_not have_issue(Puppet::Pops::Issues::IDEM_EXPRESSION_NOT_LAST)
+      end
+    end
 
-  let(:acceptor) { Puppet::Pops::Validation::Acceptor.new() }
-  let(:validator) { Puppet::Pops::Validation::ValidatorFactory_4_0.new().validator(acceptor) }
+    [
+      'if 1 {$a = 1}',
+      'if 1 {2} else {$a=1}',
+      'if 1 {2} elsif 3 {$a=1}',
+      'unless 1 {$a=1}',
+      'unless 1 {2} else {$a=1}',
+      '$a = 1 ? 2 => 3',
+      '$a = 1 ? { 2 => 3}',
+      'Foo[a] -> Foo[b]',
+      '($a=1)',
+      'foo()',
+      '$a.foo()'
+      ].each do |expr|
 
-  def validate(model)
-    validator.validate(model)
-    acceptor
+      it "does not produce error when for productive: #{expr}" do
+        source = "#{expr}; $x = 1"
+        expect(validate(parse(source))).to_not have_issue(Puppet::Pops::Issues::IDEM_EXPRESSION_NOT_LAST)
+      end
+    end
+
+    ['class', 'define', 'node'].each do |type|
+      it "flags non productive expression last in #{type}" do
+        source = <<-SOURCE
+          #{type} nope {
+            1
+          }
+          end
+        SOURCE
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::IDEM_NOT_ALLOWED_LAST)
+      end
+    end
   end
 
-  it 'should raise error for illegal names' do
-    pending "validation was too strict, now too relaxed - validation missing"
-    expect(validate(fqn('Aaa'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_NAME)
-    expect(validate(fqn('AAA'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_NAME)
+  context 'for reserved words' do
+    ['function', 'private', 'type', 'attr'].each do |word|
+      it "produces an error for the word '#{word}'" do
+        source = "$a = #{word}"
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::RESERVED_WORD)
+      end
+    end
   end
 
-  it 'should raise error for illegal variable names' do
-    expect(validate(fqn('Aaa').var())).to have_issue(Puppet::Pops::Issues::ILLEGAL_VAR_NAME)
-    expect(validate(fqn('AAA').var())).to have_issue(Puppet::Pops::Issues::ILLEGAL_VAR_NAME)
-    expect(validate(fqn('aaa::_aaa').var())).to have_issue(Puppet::Pops::Issues::ILLEGAL_VAR_NAME)
+  context 'for reserved type names' do
+    [# type/Type, is a reserved name but results in syntax error because it is a keyword in lower case form
+    'any',
+    'unit',
+    'scalar',
+    'boolean',
+    'numeric',
+    'integer',
+    'float',
+    'collection',
+    'array',
+    'hash',
+    'tuple',
+    'struct',
+    'variant',
+    'optional',
+    'enum',
+    'regexp',
+    'pattern',
+    'runtime',
+    ].each do |name|
+
+      it "produces an error for 'class #{name}'" do
+        source = "class #{name} {}"
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::RESERVED_TYPE_NAME)
+      end
+
+      it "produces an error for 'define #{name}'" do
+        source = "define #{name} {}"
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::RESERVED_TYPE_NAME)
+      end
+    end
   end
 
-  it 'should not raise error for variable name with underscore first in first name segment' do
-    expect(validate(fqn('_aa').var())).to_not have_issue(Puppet::Pops::Issues::ILLEGAL_VAR_NAME)
-    expect(validate(fqn('::_aa').var())).to_not have_issue(Puppet::Pops::Issues::ILLEGAL_VAR_NAME)
+  context 'for reserved parameter names' do
+    ['name', 'title'].each do |word|
+      it "produces an error when $#{word} is used as a parameter in a class" do
+        source = "class x ($#{word}) {}"
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::RESERVED_PARAMETER)
+      end
+
+      it "produces an error when $#{word} is used as a parameter in a define" do
+        source = "define x ($#{word}) {}"
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::RESERVED_PARAMETER)
+      end
+    end
+
+  end
+
+  context 'for numeric parameter names' do
+    ['1', '0x2', '03'].each do |word|
+      it "produces an error when $#{word} is used as a parameter in a class" do
+        source = "class x ($#{word}) {}"
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::ILLEGAL_NUMERIC_PARAMETER)
+      end
+    end
   end
 
+  def parse(source)
+    Puppet::Pops::Parser::Parser.new().parse_string(source)
+  end
 end

data/spec/unit/provider/exec/posix_spec.rb

@@ -1,19 +1,18 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
-describe Puppet::Type.type(:exec).provider(:posix) do
+describe Puppet::Type.type(:exec).provider(:posix), :if => Puppet.features.posix? do
   include PuppetSpec::Files
 
   def make_exe
     cmdpath = tmpdir('cmdpath')
     exepath = tmpfile('my_command', cmdpath)
-    exepath = exepath + ".exe" if Puppet.features.microsoft_windows?
     FileUtils.touch(exepath)
     File.chmod(0755, exepath)
     exepath
   end
 
-  let(:resource) { Puppet::Type.type(:exec).new(:title => File.expand_path('/foo'), :provider => :posix) }
+  let(:resource) { Puppet::Type.type(:exec).new(:title => '/foo', :provider => :posix) }
   let(:provider) { described_class.new(resource) }
 
   describe "#validatecmd" do
@@ -31,7 +30,7 @@ describe Puppet::Type.type(:exec).provider(:posix) do
 
     it "should pass if command is fully qualifed" do
       provider.resource[:path] = ['/bogus/bin']
-      provider.validatecmd(File.expand_path("/bin/blah/foo"))
+      provider.validatecmd("/bin/blah/foo")
     end
   end
 
@@ -64,7 +63,7 @@ describe Puppet::Type.type(:exec).provider(:posix) do
         provider.resource[:path] = [File.dirname(command)]
         filename = File.basename(command)
 
-        Puppet::Util::Execution.expects(:execute).with { |cmdline, arguments| (cmdline == filename) && (arguments.is_a? Hash) }.returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
+        Puppet::Util::Execution.expects(:execute).with(filename, instance_of(Hash)).returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
 
         provider.run(filename)
       end
@@ -91,17 +90,28 @@ describe Puppet::Type.type(:exec).provider(:posix) do
       expect { provider.run("cd ..") }.to raise_error(ArgumentError, "Could not find command 'cd'")
     end
 
+    it "does not override the user when it is already the requested user" do
+      Etc.stubs(:getpwuid).returns(Struct::Passwd.new('testing'))
+      provider.resource[:user] = 'testing'
+      command = make_exe
+
+      Puppet::Util::Execution.expects(:execute).with(anything(), has_entry(:uid, nil)).returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
+
+      provider.run(command)
+    end
+
     it "should execute the command if the command given includes arguments or subcommands" do
       provider.resource[:path] = ['/bogus/bin']
       command = make_exe
 
-      Puppet::Util::Execution.expects(:execute).with { |cmdline, arguments| (cmdline == "#{command} bar --sillyarg=true --blah") && (arguments.is_a? Hash) }.returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
+      Puppet::Util::Execution.expects(:execute).with("#{command} bar --sillyarg=true --blah", instance_of(Hash)).returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
+
       provider.run("#{command} bar --sillyarg=true --blah")
     end
 
     it "should fail if quoted command doesn't exist" do
       provider.resource[:path] = ['/bogus/bin']
-      command = "#{File.expand_path('/foo')} bar --sillyarg=true --blah"
+      command = "/foo bar --sillyarg=true --blah"
 
       expect { provider.run(%Q["#{command}"]) }.to raise_error(ArgumentError, "Could not find command '#{command}'")
     end
@@ -110,8 +120,10 @@ describe Puppet::Type.type(:exec).provider(:posix) do
       provider.resource[:environment] = ['WHATEVER=/something/else', 'WHATEVER=/foo']
       command = make_exe
 
-      Puppet::Util::Execution.expects(:execute).with { |cmdline, arguments| (cmdline == command) && (arguments.is_a? Hash) }.returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
+      Puppet::Util::Execution.expects(:execute).with(command, instance_of(Hash)).returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
+
       provider.run(command)
+
       @logs.map {|l| "#{l.level}: #{l.message}" }.should == ["warning: Overriding environment setting 'WHATEVER' with '/foo'"]
     end
 
@@ -121,7 +133,7 @@ describe Puppet::Type.type(:exec).provider(:posix) do
       provider.run(provider.resource[:command])
     end
 
-    describe "posix locale settings", :unless => Puppet.features.microsoft_windows? do
+    describe "posix locale settings" do
       # a sentinel value that we can use to emulate what locale environment variables might be set to on an international
       # system.
       lang_sentinel_value = "en_US.UTF-8"
@@ -160,7 +172,7 @@ describe Puppet::Type.type(:exec).provider(:posix) do
       end
     end
 
-    describe "posix user-related environment vars", :unless => Puppet.features.microsoft_windows? do
+    describe "posix user-related environment vars" do
       # a temporary hash that contains sentinel values for each of the user-related environment variables that we
       # are expected to unset during an "exec"
       user_sentinel_env = {}
@@ -202,10 +214,6 @@ describe Puppet::Type.type(:exec).provider(:posix) do
           output.strip.should == sentinel_value
         end
       end
-
-
     end
-
-
   end
 end

data/spec/unit/provider/exec/shell_spec.rb

@@ -2,8 +2,8 @@
 require 'spec_helper'
 
 describe Puppet::Type.type(:exec).provider(:shell), :unless => Puppet.features.microsoft_windows? do
-  let :resource do Puppet::Resource.new(:exec, 'foo') end
-  let :provider do described_class.new(resource) end
+  let(:resource) { Puppet::Type.type(:exec).new(:title => 'foo', :provider => 'shell') }
+  let(:provider) { described_class.new(resource) }
 
   describe "#run" do
     it "should be able to run builtin shell commands" do

data/spec/unit/provider/file/windows_spec.rb

@@ -49,22 +49,22 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
 
   describe "#id2name" do
     it "should return the name of the user identified by the sid" do
-      Puppet::Util::Windows::Security.expects(:valid_sid?).with(sid).returns(true)
-      Puppet::Util::Windows::Security.expects(:sid_to_name).with(sid).returns(account)
+      Puppet::Util::Windows::SID.expects(:valid_sid?).with(sid).returns(true)
+      Puppet::Util::Windows::SID.expects(:sid_to_name).with(sid).returns(account)
 
       provider.id2name(sid).should == account
     end
 
     it "should return the argument if it's already a name" do
-      Puppet::Util::Windows::Security.expects(:valid_sid?).with(account).returns(false)
-      Puppet::Util::Windows::Security.expects(:sid_to_name).never
+      Puppet::Util::Windows::SID.expects(:valid_sid?).with(account).returns(false)
+      Puppet::Util::Windows::SID.expects(:sid_to_name).never
 
       provider.id2name(account).should == account
     end
 
     it "should return nil if the user doesn't exist" do
-      Puppet::Util::Windows::Security.expects(:valid_sid?).with(sid).returns(true)
-      Puppet::Util::Windows::Security.expects(:sid_to_name).with(sid).returns(nil)
+      Puppet::Util::Windows::SID.expects(:valid_sid?).with(sid).returns(true)
+      Puppet::Util::Windows::SID.expects(:sid_to_name).with(sid).returns(nil)
 
       provider.id2name(sid).should == nil
     end
@@ -72,7 +72,7 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
 
   describe "#name2id" do
     it "should delegate to name_to_sid" do
-      Puppet::Util::Windows::Security.expects(:name_to_sid).with(account).returns(sid)
+      Puppet::Util::Windows::SID.expects(:name_to_sid).with(account).returns(sid)
 
       provider.name2id(account).should == sid
     end