puppet 3.0.0.rc5 → 3.0.0.rc7

data/spec/unit/node/facts_spec.rb

@@ -24,9 +24,9 @@ describe Puppet::Node::Facts, "when indirecting" do
     @facts.values["clientversion"].should == Puppet.version.to_s
   end
 
-  it "should add the current environment as a fact if one is not set when adding local facts" do
+  it "should not add the current environment" do
     @facts.add_local_facts
-    @facts.values["environment"].should == Puppet[:environment]
+    @facts.values.should_not include("environment")
   end
 
   it "should not replace any existing environment fact when adding local facts" do

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

@@ -11,11 +11,11 @@ describe Puppet::Parser::AST::VarDef do
   describe "when evaluating" do
 
     it "should evaluate arguments" do
-      name = mock 'name'
-      value = mock 'value'
+      name  = Puppet::Parser::AST::String.new :value => 'name'
+      value = Puppet::Parser::AST::String.new :value => 'value'
 
-      name.expects(:safeevaluate).with(@scope)
-      value.expects(:safeevaluate).with(@scope)
+      name.expects(:safeevaluate).with(@scope).returns('name')
+      value.expects(:safeevaluate).with(@scope).returns('value')
 
       vardef = Puppet::Parser::AST::VarDef.new :name => name, :value => value, :file => nil, :line => nil
       vardef.evaluate(@scope)

data/spec/unit/parser/files_spec.rb

@@ -156,6 +156,9 @@ describe Puppet::Parser::Files do
     it "should match against provided fully qualified patterns" do
       pattern = @basepath + "/fully/qualified/pattern/*"
       Dir.expects(:glob).with(pattern+'{.pp,.rb}').returns(%w{my file list})
+      ['my', 'file','list'].each do |w|
+        FileTest.expects(:'directory?').with(w).returns false
+      end
       Puppet::Parser::Files.find_manifests(pattern)[1].should == %w{my file list}
     end
 

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

@@ -18,16 +18,16 @@ describe "the 'defined' function" do
 
   it "should be true when the name is defined as a class" do
     @scope.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "yayness")
-    @scope.function_defined("yayness").should be_true
+    @scope.function_defined(["yayness"]).should be_true
   end
 
   it "should be true when the name is defined as a definition" do
     @scope.known_resource_types.add Puppet::Resource::Type.new(:definition, "yayness")
-    @scope.function_defined("yayness").should be_true
+    @scope.function_defined(["yayness"]).should be_true
   end
 
   it "should be true when the name is defined as a builtin type" do
-    @scope.function_defined("file").should be_true
+    @scope.function_defined(["file"]).should be_true
   end
 
 
@@ -37,7 +37,7 @@ describe "the 'defined' function" do
   end
 
   it "should be false when a single given name is not defined" do
-    @scope.function_defined("meh").should be_false
+    @scope.function_defined(["meh"]).should be_false
   end
 
   it "should be false when none of the names are defined" do
@@ -47,6 +47,6 @@ describe "the 'defined' function" do
   it "should be true when a resource reference is provided and the resource is in the catalog" do
     resource = Puppet::Resource.new("file", "/my/file")
     @compiler.add_resource(@scope, resource)
-    @scope.function_defined(resource).should be_true
+    @scope.function_defined([resource]).should be_true
   end
 end

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

@@ -10,7 +10,7 @@ describe "the fqdn_rand function" do
     node     = Puppet::Node.new('localhost')
     compiler = Puppet::Parser::Compiler.new(node)
     @scope   = Puppet::Parser::Scope.new(compiler)
-    @scope[:fqdn] = "127.0.0.1"
+    @scope["fqdn"] = "127.0.0.1"
   end
 
   it "should exist" do

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

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe 'Puppet::Parser::Functions#hiera_array' do
+  before :each do
+    Puppet[:hiera_config] = PuppetSpec::Files.tmpfile('hiera_config')
+  end
+
+  let :scope do Puppet::Parser::Scope.new_for_test_harness('foo') end
+
+  it 'should require a key argument' do
+    expect { scope.function_hiera_array([]) }.to raise_error(Puppet::ParseError)
+  end
+
+  it 'should raise a useful error when nil is returned' do
+    Hiera.any_instance.expects(:lookup).returns(nil)
+    expect { scope.function_hiera_array(["badkey"]) }.to raise_error(Puppet::ParseError, /Could not find data item badkey/ )
+  end
+
+  it 'should use the array resolution_type' do
+    Hiera.any_instance.expects(:lookup).with() { |*args| args[4].should be :array }.returns([])
+    scope.function_hiera_array(['key'])
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe 'Puppet::Parser::Functions#hiera_hash' do
+  let :scope do Puppet::Parser::Scope.new_for_test_harness('foo') end
+
+  it 'should require a key argument' do
+    expect { scope.function_hiera_hash([]) }.to raise_error(Puppet::ParseError)
+  end
+
+  it 'should raise a useful error when nil is returned' do
+    Hiera.any_instance.expects(:lookup).returns(nil)
+    expect { scope.function_hiera_hash(["badkey"]) }.to raise_error(Puppet::ParseError, /Could not find data item badkey/ )
+  end
+
+  it 'should use the hash resolution_type' do
+    Hiera.any_instance.expects(:lookup).with() { |*args| args[4].should be :hash }.returns({})
+    scope.function_hiera_hash(['key'])
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe 'Puppet::Parser::Functions#hiera_include' do
+  let :scope do Puppet::Parser::Scope.new_for_test_harness('foo') end
+
+  it 'should require a key argument' do
+    expect { scope.function_hiera_include([]) }.to raise_error(Puppet::ParseError)
+  end
+
+  it 'should raise a useful error when nil is returned' do
+    Hiera.any_instance.expects(:lookup).returns(nil)
+    expect { scope.function_hiera_include(["badkey"]) }.to raise_error(Puppet::ParseError, /Could not find data item badkey/ )
+  end
+
+  it 'should use the array resolution_type' do
+    Hiera.any_instance.expects(:lookup).with() { |*args| args[4].should be :array }.returns([])
+    scope.function_hiera_include(['key'])
+  end
+end

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

@@ -0,0 +1,21 @@
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+
+describe 'Puppet::Parser::Functions#hiera' do
+  let :scope do Puppet::Parser::Scope.new_for_test_harness('foo') end
+
+  it 'should require a key argument' do
+    expect { scope.function_hiera([]) }.to raise_error(Puppet::ParseError)
+  end
+
+  it 'should raise a useful error when nil is returned' do
+    Hiera.any_instance.expects(:lookup).returns(nil)
+    expect { scope.function_hiera(["badkey"]) }.to raise_error(Puppet::ParseError, /Could not find data item badkey/ )
+  end
+
+  it 'should use the priority resolution_type' do
+    Hiera.any_instance.expects(:lookup).with() { |*args| args[4].should be :priority }.returns('foo_result')
+    scope.function_hiera(['key']).should == 'foo_result'
+  end
+end

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

@@ -19,7 +19,7 @@ describe "the 'include' function" do
   it "should include a single class" do
     inc = "foo"
     @compiler.expects(:evaluate_classes).with {|klasses,parser,lazy| klasses == [inc]}.returns([inc])
-    @scope.function_include("foo")
+    @scope.function_include(["foo"])
   end
 
   it "should include multiple classes" do
@@ -42,11 +42,11 @@ describe "the 'include' function" do
 
   it "should not lazily evaluate the included class" do
     @compiler.expects(:evaluate_classes).with {|klasses,parser,lazy| lazy == false}.returns("foo")
-    @scope.function_include("foo")
+    @scope.function_include(["foo"])
   end
 
   it "should raise if the class is not found" do
     @scope.stubs(:source).returns(true)
-    expect { @scope.function_include("nosuchclass") }.to raise_error Puppet::Error
+    expect { @scope.function_include(["nosuchclass"]) }.to raise_error Puppet::Error
   end
 end

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

@@ -22,7 +22,7 @@ describe "the realize function" do
 
     Puppet::Parser::Collector.expects(:new).returns(@collector)
 
-    @scope.function_realize("test")
+    @scope.function_realize(["test"])
   end
 
   it "should assign the passed-in resources to the collector" do
@@ -30,7 +30,7 @@ describe "the realize function" do
 
     @collector.expects(:resources=).with(["test"])
 
-    @scope.function_realize("test")
+    @scope.function_realize(["test"])
   end
 
   it "should flatten the resources assigned to the collector" do
@@ -47,7 +47,7 @@ describe "the realize function" do
 
     @compiler.expects(:add_collection).with(@collector)
 
-    @scope.function_realize("test")
+    @scope.function_realize(["test"])
   end
 
 end

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

@@ -26,14 +26,14 @@ describe "the require function" do
   end
 
   it "should delegate to the 'include' puppet function" do
-    @scope.expects(:function_include).with("myclass")
+    @scope.expects(:function_include).with(["myclass"])
 
-    @scope.function_require("myclass")
+    @scope.function_require(["myclass"])
   end
 
   it "should set the 'require' prarameter on the resource to a resource reference" do
     @scope.stubs(:function_include)
-    @scope.function_require("myclass")
+    @scope.function_require(["myclass"])
 
     @resource["require"].should be_instance_of(Array)
     @resource["require"][0].should be_instance_of(Puppet::Resource)
@@ -45,7 +45,7 @@ describe "the require function" do
     @scope.expects(:find_hostclass).with("myclass").returns(@klass)
     @klass.expects(:name).returns("myclass")
 
-    @scope.function_require("myclass")
+    @scope.function_require(["myclass"])
   end
 
   it "should append the required class to the require parameter" do
@@ -53,7 +53,7 @@ describe "the require function" do
 
     one = Puppet::Resource.new(:file, "/one")
     @resource[:require] = one
-    @scope.function_require("myclass")
+    @scope.function_require(["myclass"])
 
     @resource[:require].should be_include(one)
     @resource[:require].detect { |r| r.to_s == "Class[Myclass]" }.should be_instance_of(Puppet::Resource)

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

@@ -2,10 +2,6 @@
 require 'spec_helper'
 
 describe "the shellquote function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
   let :node     do Puppet::Node.new('localhost') end
   let :compiler do Puppet::Parser::Compiler.new(node) end
   let :scope    do Puppet::Parser::Scope.new(compiler) end

data/spec/unit/parser/functions_spec.rb

@@ -22,23 +22,20 @@ describe Puppet::Parser::Functions do
     end
 
     it "should create the function in the environment module" do
-      @module.expects(:define_method).with { |name,block| name == "function_name" }
+      Puppet::Parser::Functions.newfunction("name", :type => :rvalue) { |args| }
 
-      Puppet::Parser::Functions.newfunction("name", :type => :rvalue)
+      @module.should be_method_defined :function_name
     end
 
     it "should warn if the function already exists" do
-      @module.expects(:define_method).with { |name,block| name == "function_name" }.twice
-      Puppet::Parser::Functions.newfunction("name", :type => :rvalue)
+      Puppet::Parser::Functions.newfunction("name", :type => :rvalue) { |args| }
       Puppet.expects(:warning)
 
-      Puppet::Parser::Functions.newfunction("name", :type => :rvalue)
+      Puppet::Parser::Functions.newfunction("name", :type => :rvalue) { |args| }
     end
 
     it "should raise an error if the function type is not correct" do
-      @module.expects(:define_method).with { |name,block| name == "function_name" }.never
-
-      lambda { Puppet::Parser::Functions.newfunction("name", :type => :unknown) }.should raise_error
+      lambda { Puppet::Parser::Functions.newfunction("name", :type => :unknown) { |args| } }.should raise_error Puppet::DevError, "Invalid statement type :unknown"
     end
   end
 
@@ -55,8 +52,7 @@ describe Puppet::Parser::Functions do
     end
 
     it "should return its name if the function exists" do
-      @module.expects(:define_method).with { |name,block| name == "function_name" }
-      Puppet::Parser::Functions.newfunction("name", :type => :rvalue)
+      Puppet::Parser::Functions.newfunction("name", :type => :rvalue) { |args| }
 
       Puppet::Parser::Functions.function("name").should == "function_name"
     end

data/spec/unit/parser/lexer_spec.rb

@@ -37,6 +37,18 @@ describe Puppet::Parser::Lexer do
 
       @lexer.line.should == 13
     end
+
+    {
+      'r'  => "\r",
+      'n'  => "\n",
+      't'  => "\t",
+      's'  => " "
+    }.each do |esc, expected_result|
+      it "should recognize \\#{esc} sequence" do
+        @lexer.string = "\\#{esc}'"
+        @lexer.slurpstring("'")[0].should == expected_result
+      end
+    end
   end
 end
 
@@ -458,6 +470,7 @@ describe Puppet::Parser::Lexer,"when lexing strings" do
     %q{'single quoted string with an escaped "\\'"'}                => [[:STRING,'single quoted string with an escaped "\'"']],
     %q{'single quoted string with an escaped "\$"'}                 => [[:STRING,'single quoted string with an escaped "\$"']],
     %q{'single quoted string with an escaped "\."'}                 => [[:STRING,'single quoted string with an escaped "\."']],
+    %q{'single quoted string with an escaped "\r\n"'}               => [[:STRING,'single quoted string with an escaped "\r\n"']],
     %q{'single quoted string with an escaped "\n"'}                 => [[:STRING,'single quoted string with an escaped "\n"']],
     %q{'single quoted string with an escaped "\\\\"'}               => [[:STRING,'single quoted string with an escaped "\\\\"']],
     %q{"string with an escaped '\\"'"}                              => [[:STRING,"string with an escaped '\"'"]],

data/spec/unit/parser/scope_spec.rb

@@ -83,7 +83,7 @@ describe Puppet::Parser::Scope do
     Puppet::Parser::Scope.ancestors.should include(Puppet::Resource::TypeCollectionHelper)
   end
 
-  describe "when missing methods are called" do
+  describe "when custom functions are called" do
     before :each do
       @env      = Puppet::Node::Environment.new('testing')
       @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new('foo', :environment => @env))
@@ -94,6 +94,16 @@ describe Puppet::Parser::Scope do
       @scope.function_sprintf(["%b", 123]).should == "1111011"
     end
 
+    it "should raise and error when called without an Array" do
+      expect { @scope.function_sprintf("%b", 123) }.to raise_error ArgumentError, /custom functions must be called with a single array that contains the arguments/
+    end
+
+    it "should raise and error when subsequent calls are without an Array" do
+      @scope.function_sprintf(["first call"])
+
+      expect { @scope.function_sprintf("%b", 123) }.to raise_error ArgumentError, /custom functions must be called with a single array that contains the arguments/
+    end
+
     it "should raise NoMethodError if the method doesn't look like a function" do
       expect { @scope.sprintf(["%b", 123]) }.to raise_error(NoMethodError)
     end
@@ -129,6 +139,11 @@ describe Puppet::Parser::Scope do
       @scope.lookupvar("var").should == "yep"
     end
 
+    it "should fail if invoked with a non-string name" do
+      expect { @scope[:foo] }.to raise_error Puppet::DevError
+      expect { @scope[:foo] = 12 }.to raise_error Puppet::DevError
+    end
+
     it "should return nil for unset variables" do
       @scope["var"].should be_nil
     end

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

@@ -5,10 +5,11 @@ describe Puppet::Type.type(:exec).provider(:posix) do
   include PuppetSpec::Files
 
   def make_exe
-    command = tmpfile('my_command')
-    FileUtils.touch(command)
-    File.chmod(0755, command)
-    command
+    cmdpath = tmpdir('cmdpath')
+    exepath = tmpfile('my_command', cmdpath)
+    FileUtils.touch(exepath)
+    File.chmod(0755, exepath)
+    exepath
   end
 
   let(:resource) { Puppet::Type.type(:exec).new(:title => File.expand_path('/foo'), :provider => :posix) }
@@ -74,8 +75,8 @@ describe Puppet::Type.type(:exec).provider(:posix) do
       end
 
       it "should fail if the command is in the path but not executable" do
-        command = tmpfile('foo')
-        FileUtils.touch(command)
+        command = make_exe
+        File.chmod(0644, command)
         FileTest.stubs(:executable?).with(command).returns(false)
         resource[:path] = [File.dirname(command)]
         filename = File.basename(command)

data/spec/unit/provider/group/groupadd_spec.rb

@@ -1,40 +1,46 @@
 #! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
-provider_class = Puppet::Type.type(:group).provider(:groupadd)
-
-describe provider_class do
+describe Puppet::Type.type(:group).provider(:groupadd) do
   before do
-    @resource = stub("resource", :name => "mygroup")
-    @provider = provider_class.new(@resource)
+    described_class.stubs(:command).with(:add).returns '/usr/sbin/groupadd'
+    described_class.stubs(:command).with(:delete).returns '/usr/sbin/groupdel'
+    described_class.stubs(:command).with(:modify).returns '/usr/sbin/groupmod'
   end
 
-  it "should add -o when allowdupe is enabled and the group is being created" do
-    @resource.stubs(:should).returns "fakeval"
-    @resource.stubs(:[]).returns "fakeval"
-    @resource.stubs(:system?).returns true
-    @resource.expects(:allowdupe?).returns true
-    @provider.expects(:execute).with { |args| args.include?("-o") }
-
-    @provider.create
+  let(:resource) { Puppet::Type.type(:group).new(:name => 'mygroup', :provider => provider) }
+  let(:provider) { described_class.new(:name => 'mygroup') }
+
+  describe "#create" do
+    it "should add -o when allowdupe is enabled and the group is being created" do
+      resource[:allowdupe] = :true
+      provider.expects(:execute).with(['/usr/sbin/groupadd', '-o', 'mygroup'])
+      provider.create
+    end
+
+    describe "on system that feature system_groups", :if => described_class.system_groups? do
+      it "should add -r when system is enabled and the group is being created" do
+        resource[:system] = :true
+        provider.expects(:execute).with(['/usr/sbin/groupadd', '-r', 'mygroup'])
+        provider.create
+      end
+    end
+
+    describe "on system that do not feature system_groups", :unless => described_class.system_groups? do
+      it "should not add -r when system is enabled and the group is being created" do
+        resource[:system] = :true
+        provider.expects(:execute).with(['/usr/sbin/groupadd', 'mygroup'])
+        provider.create
+      end
+    end
   end
 
-  it "should add -o when allowdupe is enabled and the gid is being modified" do
-    @resource.stubs(:should).returns "fakeval"
-    @resource.stubs(:[]).returns "fakeval"
-    @resource.expects(:allowdupe?).returns true
-    @provider.expects(:execute).with { |args| args.include?("-o") }
-
-    @provider.gid = 150
-  end
-
-  it "should add -r when system is enabled and the group is being created" do
-    @resource.stubs(:should).returns "fakeval"
-    @resource.stubs(:[]).returns "fakeval"
-    @resource.expects(:system?).returns true
-    @resource.stubs(:allowdupe?).returns true
-    @provider.expects(:execute).with { |args| args.include?("-r") }
-
-    @provider.create
+  describe "#gid=" do
+    it "should add -o when allowdupe is enabled and the gid is being modified" do
+      resource[:allowdupe] = :true
+      provider.expects(:execute).with(['/usr/sbin/groupmod', '-g', 150, '-o', 'mygroup'])
+      provider.gid = 150
+    end
   end
 end
+