puppet 2.7.1 → 2.7.3

data/spec/unit/parser/lexer_spec.rb

@@ -230,22 +230,6 @@ describe Puppet::Parser::Lexer::TOKENS do
   end
 end
 
-describe Puppet::Parser::Lexer::TOKENS[:CLASSNAME] do
-  before { @token = Puppet::Parser::Lexer::TOKENS[:CLASSNAME] }
-
-  it "should match against lower-case alpha-numeric terms separated by double colons" do
-    @token.regex.should =~ "one::two"
-  end
-
-  it "should match against many lower-case alpha-numeric terms separated by double colons" do
-    @token.regex.should =~ "one::two::three::four::five"
-  end
-
-  it "should match against lower-case alpha-numeric terms prefixed by double colons" do
-    @token.regex.should =~ "::one"
-  end
-end
-
 describe Puppet::Parser::Lexer::TOKENS[:CLASSREF] do
   before { @token = Puppet::Parser::Lexer::TOKENS[:CLASSREF] }
 
@@ -295,6 +279,22 @@ describe Puppet::Parser::Lexer::TOKENS[:NAME] do
     Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(keyword)
     @token.convert(stub('lexer'), "false").should == [Puppet::Parser::Lexer::TOKENS[:BOOLEAN], false]
   end
+
+  it "should match against lower-case alpha-numeric terms separated by double colons" do
+    @token.regex.should =~ "one::two"
+  end
+
+  it "should match against many lower-case alpha-numeric terms separated by double colons" do
+    @token.regex.should =~ "one::two::three::four::five"
+  end
+
+  it "should match against lower-case alpha-numeric terms prefixed by double colons" do
+    @token.regex.should =~ "::one"
+  end
+
+  it "should match against nested terms starting with numbers" do
+    @token.regex.should =~ "::1one::2two::3three"
+  end
 end
 
 describe Puppet::Parser::Lexer::TOKENS[:NUMBER] do
@@ -445,6 +445,9 @@ describe Puppet::Parser::Lexer,"when lexing strings" do
     %q["foo$bar$"]                                                  => [[:DQPRE,"foo"],[:VARIABLE,"bar"],[:DQPOST,"$"]],
     %q["foo$$bar"]                                                  => [[:DQPRE,"foo$"],[:VARIABLE,"bar"],[:DQPOST,""]],
     %q[""]                                                          => [[:STRING,""]],
+    %q["123 456 789 0"]                                             => [[:STRING,"123 456 789 0"]],
+    %q["${123} 456 $0"]                                             => [[:DQPRE,""],[:VARIABLE,"123"],[:DQMID," 456 "],[:VARIABLE,"0"],[:DQPOST,""]],
+    %q["$foo::::bar"]                                               => [[:DQPRE,""],[:VARIABLE,"foo"],[:DQPOST,"::::bar"]]
   }.each { |src,expected_result|
     it "should handle #{src} correctly" do
       tokens_scanned_from(src).should be_like(*expected_result)
@@ -660,10 +663,17 @@ describe "Puppet::Parser::Lexer in the old tests" do
   end
 
   it "should correctly lex variables" do
-    ["$variable", "$::variable", "$qualified::variable", "$further::qualified::variable"].each do |string|
+    ["$variable", "$::variable", "$qualified::variable", "$further::qualified::variable", "$hyphenated-variable", "$-variable-with-leading-dash"].each do |string|
       tokens_scanned_from(string).should be_like([:VARIABLE,string.sub(/^\$/,'')])
     end
   end
+
+  it "should not include whitespace in a variable" do
+    tokens_scanned_from("$foo bar").should_not be_like([:VARIABLE, "foo bar"])
+  end
+  it "should not include excess colons in a variable" do
+    tokens_scanned_from("$foo::::bar").should_not be_like([:VARIABLE, "foo::::bar"])
+  end
 end
 
 describe "Puppet::Parser::Lexer in the old tests when lexing example files" do

data/spec/unit/parser/resource_spec.rb

@@ -131,9 +131,19 @@ describe Puppet::Parser::Resource do
   end
 
   describe "when evaluating" do
+    before do
+      @node = Puppet::Node.new "test-node"
+      @compiler = Puppet::Parser::Compiler.new @node
+      @catalog = Puppet::Resource::Catalog.new
+      source = stub('source')
+      source.stubs(:module_name)
+      @scope = Puppet::Parser::Scope.new(:compiler => @compiler, :source => source)
+      @catalog.add_resource(Puppet::Parser::Resource.new("stage", :main, :scope => @scope))
+    end
+
     it "should evaluate the associated AST definition" do
       definition = newdefine "mydefine"
-      res = Puppet::Parser::Resource.new("mydefine", "whatever", :scope => @scope, :source => @source)
+      res = Puppet::Parser::Resource.new("mydefine", "whatever", :scope => @scope, :source => @source, :catalog => @catalog)
       definition.expects(:evaluate_code).with(res)
 
       res.evaluate
@@ -141,17 +151,65 @@ describe Puppet::Parser::Resource do
 
     it "should evaluate the associated AST class" do
       @class = newclass "myclass"
-      res = Puppet::Parser::Resource.new("class", "myclass", :scope => @scope, :source => @source)
+      res = Puppet::Parser::Resource.new("class", "myclass", :scope => @scope, :source => @source, :catalog => @catalog)
       @class.expects(:evaluate_code).with(res)
       res.evaluate
     end
 
     it "should evaluate the associated AST node" do
       nodedef = newnode("mynode")
-      res = Puppet::Parser::Resource.new("node", "mynode", :scope => @scope, :source => @source)
+      res = Puppet::Parser::Resource.new("node", "mynode", :scope => @scope, :source => @source, :catalog => @catalog)
       nodedef.expects(:evaluate_code).with(res)
       res.evaluate
     end
+
+    it "should add an edge to any specified stage for class resources", :'fails_on_ruby_1.9.2' => true do
+      @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", '')
+
+      other_stage = Puppet::Parser::Resource.new(:stage, "other", :scope => @scope, :catalog => @catalog)
+      @compiler.add_resource(@scope, other_stage)
+      resource = Puppet::Parser::Resource.new(:class, "foo", :scope => @scope, :catalog => @catalog)
+      resource[:stage] = 'other'
+      @compiler.add_resource(@scope, resource)
+
+      resource.evaluate
+
+      @compiler.catalog.edge?(other_stage, resource).should be_true
+    end
+
+    it "should fail if an unknown stage is specified", :'fails_on_ruby_1.9.2' => true do
+      @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", '')
+
+      resource = Puppet::Parser::Resource.new(:class, "foo", :scope => @scope, :catalog => @catalog)
+      resource[:stage] = 'other'
+
+      lambda { resource.evaluate }.should raise_error(ArgumentError, /Could not find stage other specified by/)
+    end
+
+    it "should add edges from the class resources to the parent's stage if no stage is specified", :'fails_on_ruby_1.9.2' => true do
+      main      = @compiler.catalog.resource(:stage, :main)
+      foo_stage = Puppet::Parser::Resource.new(:stage, :foo_stage, :scope => @scope, :catalog => @catalog)
+      @compiler.add_resource(@scope, foo_stage)
+      @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", '')
+      resource = Puppet::Parser::Resource.new(:class, "foo", :scope => @scope, :catalog => @catalog)
+      resource[:stage] = 'foo_stage'
+      @compiler.add_resource(@scope, resource)
+
+      resource.evaluate
+
+      @compiler.catalog.should be_edge(foo_stage, resource)
+    end
+
+    it "should add edges from top-level class resources to the main stage if no stage is specified", :'fails_on_ruby_1.9.2' => true do
+      main = @compiler.catalog.resource(:stage, :main)
+      @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", '')
+      resource = Puppet::Parser::Resource.new(:class, "foo", :scope => @scope, :catalog => @catalog)
+      @compiler.add_resource(@scope, resource)
+
+      resource.evaluate
+
+      @compiler.catalog.should be_edge(main, resource)
+    end
   end
 
   describe "when finishing" do

data/spec/unit/parser/scope_spec.rb

@@ -121,7 +121,11 @@ describe Puppet::Parser::Scope do
 
       def create_class_scope(name)
         klass = newclass(name)
-        Puppet::Parser::Resource.new("class", name, :scope => @scope, :source => mock('source')).evaluate
+
+        catalog = Puppet::Resource::Catalog.new
+        catalog.add_resource(Puppet::Parser::Resource.new("stage", :main, :scope => Puppet::Parser::Scope.new))
+
+        Puppet::Parser::Resource.new("class", name, :scope => @scope, :source => mock('source'), :catalog => catalog).evaluate
 
         @scope.class_scope(klass)
       end

data/spec/unit/provider/augeas/augeas_spec.rb

@@ -4,7 +4,6 @@ require 'spec_helper'
 provider_class = Puppet::Type.type(:augeas).provider(:augeas)
 
 describe provider_class do
-
   describe "command parsing" do
     before do
       @resource = stub("resource")
@@ -252,6 +251,7 @@ describe provider_class do
     it "should handle no filters" do
       resource = stub("resource")
       resource.stubs(:[]).returns(false).then.returns("").then.returns("")
+      resource.stubs(:noop?).returns(false)
       augeas_stub = stub("augeas", :match => ["set", "of", "values"])
       augeas_stub.stubs("close")
       provider = provider_class.new(resource)
@@ -263,6 +263,7 @@ describe provider_class do
     it "should return true when a get filter matches" do
       resource = stub("resource")
       resource.stubs(:[]).returns(false).then.returns("get path == value").then.returns("")
+      resource.stubs(:noop?).returns(false)
       provider = provider_class.new(resource)
       augeas_stub = stub("augeas", :get => "value")
       augeas_stub.stubs("close")
@@ -285,6 +286,7 @@ describe provider_class do
     it "should return true when a match filter matches" do
       resource = stub("resource")
       resource.stubs(:[]).returns(false).then.returns("match path size == 3").then.returns("")
+      resource.stubs(:noop?).returns(false)
       provider = provider_class.new(resource)
       augeas_stub = stub("augeas", :match => ["set", "of", "values"])
       augeas_stub.stubs("close")
@@ -320,6 +322,7 @@ describe provider_class do
     it "should return true when a size != the provided value" do
       resource = stub("resource")
       resource.stubs(:[]).returns(false).then.returns("match path size != 17").then.returns("")
+      resource.stubs(:noop?).returns(false)
       provider = provider_class.new(resource)
       augeas_stub = stub("augeas", :match => ["set", "of", "values"])
       augeas_stub.stubs("close")
@@ -339,6 +342,107 @@ describe provider_class do
       provider.stubs(:get_augeas_version).returns("0.3.5")
       provider.need_to_run?.should == false
     end
+
+    # Ticket 2728 (diff files)
+    describe "and Puppet[:show_diff] is set", :if => Puppet.features.augeas? do
+      before do
+        Puppet[:show_diff] = true
+
+        @resource = Puppet::Type.type(:augeas).new(:name => "test")
+        @provider = provider_class.new(@resource)
+        @augeas_stub = stub("augeas")
+        @provider.aug = @augeas_stub
+
+        @augeas_stub.stubs("get").with("/augeas/version").returns("0.7.2")
+        @augeas_stub.stubs(:set).returns(true)
+        @augeas_stub.stubs(:save).returns(true)
+      end
+
+      it "should call diff when a file is shown to have been changed" do
+        file = "/etc/hosts"
+
+        @resource[:context] = "/files"
+        @resource[:changes] = ["set #{file}/foo bar"]
+
+        @augeas_stub.stubs(:match).with("/augeas/events/saved").returns(["/augeas/events/saved"])
+        @augeas_stub.stubs(:get).with("/augeas/events/saved").returns(["/files#{file}"])
+        @augeas_stub.expects(:set).with("/augeas/save", "newfile")
+        @augeas_stub.expects(:close).never()
+
+        @provider.expects("diff").with("#{file}", "#{file}.augnew").returns("")
+        @provider.should be_need_to_run
+      end
+
+      it "should call diff for each file thats changed" do
+        file1 = "/etc/hosts"
+        file2 = "/etc/resolv.conf"
+
+        @resource[:context] = "/files"
+        @resource[:changes] = ["set #{file1}/foo bar", "set #{file2}/baz biz"]
+
+        @augeas_stub.stubs(:match).with("/augeas/events/saved").returns(["/augeas/events/saved[1]", "/augeas/events/saved[2]"])
+        @augeas_stub.stubs(:get).with("/augeas/events/saved[1]").returns(["/files#{file1}"])
+        @augeas_stub.stubs(:get).with("/augeas/events/saved[2]").returns(["/files#{file2}"])
+        @augeas_stub.expects(:set).with("/augeas/save", "newfile")
+        @augeas_stub.expects(:close).never()
+
+        @provider.expects(:diff).with("#{file1}", "#{file1}.augnew").returns("")
+        @provider.expects(:diff).with("#{file2}", "#{file2}.augnew").returns("")
+        @provider.should be_need_to_run
+      end
+
+      describe "and resource[:root] is set" do
+        it "should call diff when a file is shown to have been changed" do
+          root = "/tmp/foo"
+          file = "/etc/hosts"
+
+          @resource[:context] = "/files"
+          @resource[:changes] = ["set #{file}/foo bar"]
+          @resource[:root] = root
+
+          @augeas_stub.stubs(:match).with("/augeas/events/saved").returns(["/augeas/events/saved"])
+          @augeas_stub.stubs(:get).with("/augeas/events/saved").returns(["/files#{file}"])
+          @augeas_stub.expects(:set).with("/augeas/save", "newfile")
+          @augeas_stub.expects(:close).never()
+
+          @provider.expects(:diff).with("#{root}#{file}", "#{root}#{file}.augnew").returns("")
+          @provider.should be_need_to_run
+        end
+      end
+
+      it "should not call diff if no files change" do
+        file = "/etc/hosts"
+
+        @resource[:context] = "/files"
+        @resource[:changes] = ["set #{file}/foo bar"]
+
+        @augeas_stub.stubs(:match).with("/augeas/events/saved").returns([])
+        @augeas_stub.expects(:set).with("/augeas/save", "newfile")
+        @augeas_stub.expects(:get).with("/augeas/events/saved").never()
+        @augeas_stub.expects(:close)
+
+        @provider.expects(:diff).never()
+        @provider.should_not be_need_to_run
+      end
+
+      it "should cleanup when in noop mode" do
+        file = "/etc/hosts"
+
+        @resource[:noop] = true
+        @resource[:context] = "/files"
+        @resource[:changes] = ["set #{file}/foo bar"]
+
+        @augeas_stub.stubs(:match).with("/augeas/events/saved").returns(["/augeas/events/saved"])
+        @augeas_stub.stubs(:get).with("/augeas/events/saved").returns(["/files#{file}"])
+        @augeas_stub.expects(:set).with("/augeas/save", "newfile")
+        @augeas_stub.expects(:close)
+
+        File.expects(:delete).with(file + ".augnew")
+
+        @provider.expects(:diff).with("#{file}", "#{file}.augnew").returns("")
+        @provider.should be_need_to_run
+      end
+    end
   end
 
   describe "augeas execution integration" do
@@ -349,6 +453,7 @@ describe provider_class do
       @augeas = stub("augeas")
       @provider.aug= @augeas
       @provider.stubs(:get_augeas_version).returns("0.3.5")
+      @augeas.stubs(:match).with("/augeas/events/saved")
     end
 
     it "should handle set commands" do

data/spec/unit/provider/cisco_spec.rb

@@ -1,6 +1,5 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 require 'puppet/provider/cisco'
 
@@ -13,4 +12,4 @@ describe Puppet::Provider::Cisco do
     Puppet::Util::NetworkDevice::Cisco::Device.expects(:new).returns :device
     Puppet::Provider::Cisco.device(:url).should == :device
   end
-end
+end

data/spec/unit/provider/interface/cisco_spec.rb

@@ -1,6 +1,5 @@
 #!/usr/bin/env rspec
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'spec_helper'
 
 require 'puppet/provider/interface/cisco'
 

data/spec/unit/provider/mount/parsed_spec.rb

@@ -193,6 +193,47 @@ FSTAB
 
   my_fixtures('*.fstab').each do |fstab|
     platform = File.basename(fstab, '.fstab')
+
+    describe "when calling instances on #{platform}" do
+      before :each do
+        if Facter[:operatingsystem] == "Solaris" then
+          platform == 'solaris' or
+            pending "We need to stub the operatingsystem fact at load time, but can't"
+        else
+          platform != 'solaris' or
+            pending "We need to stub the operatingsystem fact at load time, but can't"
+        end
+
+        # Stub the mount output to our fixture.
+        begin
+          mount = my_fixture(platform + '.mount')
+          @provider.stubs(:mountcmd).returns File.read(mount)
+        rescue
+          pending "is #{platform}.mount missing at this point?"
+        end
+
+        # Note: we have to stub default_target before creating resources
+        # because it is used by Puppet::Type::Mount.new to populate the
+        # :target property.
+        @provider.stubs(:default_target).returns fstab
+        @retrieve = @provider.instances.collect { |prov| {:name => prov.get(:name), :ensure => prov.get(:ensure)}}
+      end
+
+      # Following mountpoint are present in all fstabs/mountoutputs
+      it "should include unmounted resources" do
+        @retrieve.should include(:name => '/', :ensure => :mounted)
+      end
+
+      it "should include mounted resources" do
+        @retrieve.should include(:name => '/boot', :ensure => :unmounted)
+      end
+
+      it "should include ghost resources" do
+        @retrieve.should include(:name => '/ghost', :ensure => :ghost)
+      end
+
+    end
+
     describe "when prefetching on #{platform}" do
       before :each do
         if Facter[:operatingsystem] == "Solaris" then

data/spec/unit/provider/nameservice/directoryservice_spec.rb

@@ -35,3 +35,63 @@ require 'spec_helper'
     end
   end
 end
+
+describe 'DirectoryService.single_report' do
+  it 'should fail on OS X < 10.4' do
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_macosx_version_major).returns("10.3")
+
+    lambda {
+      Puppet::Provider::NameService::DirectoryService.single_report('resource_name')
+    }.should raise_error(RuntimeError, "Puppet does not support OS X versions < 10.4")
+  end
+
+  it 'should use url data on 10.4' do
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_macosx_version_major).returns("10.4")
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_ds_path).returns('Users')
+    Puppet::Provider::NameService::DirectoryService.stubs(:list_all_present).returns(
+      ['root', 'user1', 'user2', 'resource_name']
+    )
+    Puppet::Provider::NameService::DirectoryService.stubs(:generate_attribute_hash)
+    Puppet::Provider::NameService::DirectoryService.stubs(:execute)
+    Puppet::Provider::NameService::DirectoryService.expects(:parse_dscl_url_data)
+
+    Puppet::Provider::NameService::DirectoryService.single_report('resource_name')
+  end
+
+  it 'should use plist data on > 10.4' do
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_macosx_version_major).returns("10.5")
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_ds_path).returns('Users')
+    Puppet::Provider::NameService::DirectoryService.stubs(:list_all_present).returns(
+      ['root', 'user1', 'user2', 'resource_name']
+    )
+    Puppet::Provider::NameService::DirectoryService.stubs(:generate_attribute_hash)
+    Puppet::Provider::NameService::DirectoryService.stubs(:execute)
+    Puppet::Provider::NameService::DirectoryService.expects(:parse_dscl_plist_data)
+
+    Puppet::Provider::NameService::DirectoryService.single_report('resource_name')
+  end
+end
+
+describe 'DirectoryService.get_exec_preamble' do
+  it 'should fail on OS X < 10.4' do
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_macosx_version_major).returns("10.3")
+
+    lambda {
+      Puppet::Provider::NameService::DirectoryService.get_exec_preamble('-list')
+    }.should raise_error(RuntimeError, "Puppet does not support OS X versions < 10.4")
+  end
+
+  it 'should use url data on 10.4' do
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_macosx_version_major).returns("10.4")
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_ds_path).returns('Users')
+
+    Puppet::Provider::NameService::DirectoryService.get_exec_preamble('-list').should include("-url")
+  end
+
+  it 'should use plist data on > 10.4' do
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_macosx_version_major).returns("10.5")
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_ds_path).returns('Users')
+
+    Puppet::Provider::NameService::DirectoryService.get_exec_preamble('-list').should include("-plist")
+  end
+end