puppet 3.0.2 → 3.1.0.rc1

data/spec/unit/provider/service/src_spec.rb

@@ -35,12 +35,12 @@ describe provider_class do
   end
 
   it "should execute the startsrc command" do
-    @provider.expects(:execute).with(['/usr/bin/startsrc', '-s', "myservice"], {:squelch => true, :failonfail => true})
+    @provider.expects(:execute).with(['/usr/bin/startsrc', '-s', "myservice"], {:override_locale => false, :squelch => true, :failonfail => true})
     @provider.start
   end
 
   it "should execute the stopsrc command" do
-    @provider.expects(:execute).with(['/usr/bin/stopsrc', '-s', "myservice"], {:squelch => true, :failonfail => true})
+    @provider.expects(:execute).with(['/usr/bin/stopsrc', '-s', "myservice"], {:override_locale => false, :squelch => true, :failonfail => true})
     @provider.stop
   end
 
@@ -90,8 +90,8 @@ _EOF_
 myservice::--no-daemonize:/usr/sbin/puppetd:0:0:/dev/null:/var/log/puppet.log:/var/log/puppet.log:-O:-Q:-S:0:0:20:15:9:-d:20::"
 _EOF_
     @provider.expects(:execute).with(['/usr/bin/lssrc', '-Ss', "myservice"]).returns sample_output
-    @provider.expects(:execute).with(['/usr/bin/stopsrc', '-s', "myservice"], {:squelch => true, :failonfail => true})
-    @provider.expects(:execute).with(['/usr/bin/startsrc', '-s', "myservice"], {:squelch => true, :failonfail => true})
+    @provider.expects(:execute).with(['/usr/bin/stopsrc', '-s', "myservice"], {:override_locale => false, :squelch => true, :failonfail => true})
+    @provider.expects(:execute).with(['/usr/bin/startsrc', '-s', "myservice"], {:override_locale => false, :squelch => true, :failonfail => true})
     @provider.restart
   end
 end

data/spec/unit/provider/service/systemd_spec.rb

@@ -17,14 +17,6 @@ describe provider_class do
     @provider.resource = @resource
   end
 
-  osfamily = [ 'redhat', 'suse' ]
-
-  osfamily.each do |osfamily|
-    it "should be the default provider on #{osfamily}" do
-      pending "This test is pending the change in RedHat-related Linuxes to systemd for service management"
-    end
-  end
-
   [:enabled?, :enable, :disable, :start, :stop, :status, :restart].each do |method|
     it "should have a #{method} method" do
       @provider.should respond_to(method)

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

@@ -119,7 +119,7 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
       resource[:restart] = 'c:/bin/foo'
 
       provider.expects(:execute).never
-      provider.expects(:execute).with(['c:/bin/foo'], :failonfail => true, :squelch => true)
+      provider.expects(:execute).with(['c:/bin/foo'], :failonfail => true, :override_locale => false, :squelch => true)
 
       provider.restart
     end

data/spec/unit/provider/user/useradd_spec.rb

@@ -126,25 +126,18 @@ describe Puppet::Type.type(:user).provider(:useradd) do
     end
 
     it "should return an array with -M if home is not managed and on Redhat" do
-      Facter.stubs(:value).with(:operatingsystem).returns("RedHat")
+      Facter.stubs(:value).with(:osfamily).returns("RedHat")
       resource[:managehome] = :false
       provider.check_manage_home.must == ["-M"]
     end
 
     it "should return an empty array if home is not managed and not on Redhat" do
-      Facter.stubs(:value).with(:operatingsystem).returns("some OS")
+      Facter.stubs(:value).with(:osfamily).returns("not RedHat")
       resource[:managehome] = :false
       provider.check_manage_home.must == []
     end
   end
 
-  describe "when adding properties" do
-    it "should get the valid properties"
-    it "should not add the ensure property"
-    it "should add the flag and value to an array"
-    it "should return and array of flags and values"
-  end
-
   describe "#addcmd" do
     before do
       resource[:allowdupe] = :true

data/spec/unit/relationship_spec.rb

@@ -151,7 +151,7 @@ describe Puppet::Relationship, " when matching edges with a non-standard event"
   end
 end
 
-describe Puppet::Relationship, "when converting to pson", :if => Puppet.features.pson? do
+describe Puppet::Relationship, "when converting to pson" do
   before do
     @edge = Puppet::Relationship.new(:a, :b, :event => :random, :callback => :whatever)
   end
@@ -184,7 +184,7 @@ describe Puppet::Relationship, "when converting to pson", :if => Puppet.features
   end
 end
 
-describe Puppet::Relationship, "when converting from pson", :if => Puppet.features.pson? do
+describe Puppet::Relationship, "when converting from pson" do
   before do
     @event = "random"
     @callback = "whatever"

data/spec/unit/resource/catalog_spec.rb

@@ -775,7 +775,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
   end
 end
 
-describe Puppet::Resource::Catalog, "when converting to pson", :if => Puppet.features.pson? do
+describe Puppet::Resource::Catalog, "when converting to pson" do
   before do
     @catalog = Puppet::Resource::Catalog.new("myhost")
   end
@@ -833,7 +833,7 @@ describe Puppet::Resource::Catalog, "when converting to pson", :if => Puppet.fea
   end
 end
 
-describe Puppet::Resource::Catalog, "when converting from pson", :if => Puppet.features.pson? do
+describe Puppet::Resource::Catalog, "when converting from pson" do
   def pson_result_should
     Puppet::Resource::Catalog.expects(:new).with { |hash| yield hash }
   end

data/spec/unit/resource/type_spec.rb

@@ -8,7 +8,7 @@ describe Puppet::Resource::Type do
     Puppet::Resource::Type.new(:hostclass, "foo").name.should == "foo"
   end
 
-  [:code, :doc, :line, :file, :resource_type_collection, :ruby_code].each do |attr|
+  [:code, :doc, :line, :file, :resource_type_collection].each do |attr|
     it "should have a '#{attr}' attribute" do
       type = Puppet::Resource::Type.new(:hostclass, "foo")
       type.send(attr.to_s + "=", "yay")
@@ -16,6 +16,22 @@ describe Puppet::Resource::Type do
     end
   end
 
+  it "returns array when calling ruby_code" do
+    Puppet::Resource::Type.new(:hostclass, "foo").ruby_code.should be_an Array
+  end
+
+  it "assignment operator should append to ruby_code" do
+    type = Puppet::Resource::Type.new :hostclass, 'foo'
+    type.ruby_code << "code"
+    type.ruby_code << "more code"
+    type.ruby_code.should == ["code", "more code"]
+  end
+
+  it "has ruby_code attribute" do
+    type = Puppet::Resource::Type.new(:hostclass, "foo")
+    type.ruby_code.should == []
+  end
+
   [:hostclass, :node, :definition].each do |type|
     it "should know when it is a #{type}" do
       Puppet::Resource::Type.new(type, "foo").send("#{type}?").should be_true
@@ -150,24 +166,6 @@ describe Puppet::Resource::Type do
         Puppet::Resource::Type.new(:node, "fOo").match("foO").should be_true
       end
     end
-
-    it "should return the name converted to a string when the name is not a regex" do
-      pending "Need to define LoadedCode behaviour first"
-      name = Puppet::Parser::AST::HostName.new(:value => "foo")
-      Puppet::Resource::Type.new(:node, name).name.should == "foo"
-    end
-
-    it "should return the name converted to a string when the name is a regex" do
-      pending "Need to define LoadedCode behaviour first"
-      name = Puppet::Parser::AST::HostName.new(:value => /regex/)
-      Puppet::Resource::Type.new(:node, name).name.should == /regex/.to_s
-    end
-
-    it "should mark any created scopes as a node scope" do
-      pending "Need to define LoadedCode behaviour first"
-      name = Puppet::Parser::AST::HostName.new(:value => /regex/)
-      Puppet::Resource::Type.new(:node, name).name.should == /regex/.to_s
-    end
   end
 
   describe "when initializing" do
@@ -469,12 +467,10 @@ describe Puppet::Resource::Type do
     end
 
     describe "and ruby code is provided" do
-      it "should create a DSL Resource API and evaluate it" do
-        @type.stubs(:ruby_code).returns(proc { "foo" })
-        @api = stub 'api'
-        Puppet::DSL::ResourceAPI.expects(:new).with { |res, scope, code| code == @type.ruby_code }.returns @api
-        @api.expects(:evaluate)
-
+      it "should evaluate ruby code" do
+        code = stub 'code'
+        code.expects(:evaluate).with {|scope, type_collection| scope.is_a? Puppet::Parser::Scope and type_collection.is_a? Puppet::Resource::TypeCollection }
+        @type.stubs(:ruby_code).returns(Array(code))
         @type.evaluate_code(@resource)
       end
     end
@@ -733,6 +729,34 @@ describe Puppet::Resource::Type do
       dest.doc.should == "foonessyayness"
     end
 
+    it "copies other's ruby code if it has no ruby code" do
+      dest   = Puppet::Resource::Type.new :hostclass, "bar"
+      source = Puppet::Resource::Type.new :hostclass, "foo"
+      source.ruby_code << "bar"
+
+      dest.merge source
+      dest.ruby_code.should == ["bar"]
+    end
+
+    it "appends other's ruby code if it has ruby code" do
+      dest   = Puppet::Resource::Type.new :hostclass, "bar"
+      source = Puppet::Resource::Type.new :hostclass, "foo"
+      dest.ruby_code   << "foo"
+      source.ruby_code << "bar"
+
+      dest.merge source
+      dest.ruby_code.should == ["foo", "bar"]
+    end
+
+    it "returns own ruby code if the other has no ruby code" do
+      dest   = Puppet::Resource::Type.new :hostclass, "bar", :ruby_code => "foo"
+      source = Puppet::Resource::Type.new :hostclass, "foo"
+      dest.ruby_code << "foo"
+
+      dest.merge source
+      dest.ruby_code.should == ["foo"]
+    end
+
     it "should turn its code into an ASTArray if necessary" do
       dest = Puppet::Resource::Type.new(:hostclass, "bar", :code => code("foo"))
       source = Puppet::Resource::Type.new(:hostclass, "foo", :code => code("bar"))

data/spec/unit/resource_spec.rb

@@ -15,6 +15,7 @@ describe Puppet::Resource do
     end
   end
 
+
   it "should have a :title attribute" do
     Puppet::Resource.new(:user, "foo").title.should == "foo"
   end
@@ -305,6 +306,33 @@ describe Puppet::Resource do
       resource.set_default_parameters(@scope).should == ["a"]
     end
 
+    it "doesn't call safeevaluate on default value when it doesn't respond to safeevaluate" do
+      Puppet[:manifest] = "test.rb"
+      value = mock
+      value.stubs(:respond_to?).with(:safeevaluate).returns false
+      value.expects(:safeevaluate).never
+      Puppet::Node::Environment.new.known_resource_types.add(
+        Puppet::Resource::Type.new :definition, "default_param", :arguments => {"a" => value}
+      )
+
+      resource = Puppet::Parser::Resource.new "default_param", "name", :scope => Puppet::Parser::Scope.new(Puppet::Parser::Compiler.new(Puppet::Node.new("foo")))
+      resource.set_default_parameters @scope
+    end
+
+
+    it "calls safeevaluate on default when it responds to safeevaluate" do
+      value = mock
+      value.expects(:safeevaluate).returns 42
+      Puppet::Node::Environment.new.known_resource_types.add(
+        Puppet::Resource::Type.new :definition, "default_param", :arguments => {"a" => value}
+      )
+
+      resource = Puppet::Parser::Resource.new "default_param", "name", :scope => Puppet::Parser::Scope.new(Puppet::Parser::Compiler.new(Puppet::Node.new("foo")))
+      resource.set_default_parameters @scope
+    end
+
+
+
     describe "when the resource type is :hostclass" do
       let(:environment_name) { "testing env" }
       let(:fact_values) { { :a => 1 } }
@@ -647,7 +675,7 @@ type: File
     end
   end
 
-  describe "when converting to pson", :if => Puppet.features.pson? do
+  describe "when converting to pson" do
     def pson_output_should
       @resource.class.expects(:pson_create).with { |hash| yield hash }
     end
@@ -726,7 +754,7 @@ type: File
     end
   end
 
-  describe "when converting from pson", :if => Puppet.features.pson? do
+  describe "when converting from pson" do
     def pson_result_should
       Puppet::Resource.expects(:new).with { |hash| yield hash }
     end
@@ -965,4 +993,8 @@ type: File
       })
     end
   end
+
+  it "should be able to return canonical type name" do
+    Puppet::Resource.canonicalize_type("foo").should == "Foo"
+  end
 end

data/spec/unit/settings/config_file_spec.rb

@@ -0,0 +1,100 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+require 'puppet/settings/config_file'
+
+describe Puppet::Settings::ConfigFile do
+  NOTHING = {}
+
+  def section_containing(data)
+    meta = data[:meta] || {}
+    values = data.reject { |key, _| key == :meta }
+    values.merge({ :_meta => Hash[values.keys.collect { |key| [key, meta[key] || {}] }] })
+  end
+
+  def the_parse_of(*lines)
+    config.parse_file(filename, lines.join("\n"))
+  end
+
+  let(:identity_transformer) { Proc.new { |value| value } }
+  let(:config) { Puppet::Settings::ConfigFile.new(identity_transformer) }
+
+  let(:filename) { "a/fake/filename.conf" }
+
+  it "interprets an empty file to contain a main section with no entries" do
+    the_parse_of("").should == { :main => section_containing(NOTHING) }
+  end
+
+  it "interprets an empty main section the same as an empty file" do
+    the_parse_of("").should == config.parse_file(filename, "[main]")
+  end
+
+  it "places an entry in no section in main" do
+    the_parse_of("var = value").should == { :main => section_containing(:var => "value") }
+  end
+
+  it "places an entry after a section header in that section" do
+    the_parse_of("[section]", "var = value").should == { :main => section_containing(NOTHING),
+                                                       :section => section_containing(:var => "value") }
+  end
+
+  it "does not include trailing whitespace in the value" do
+    the_parse_of("var = value\t ").should == { :main => section_containing(:var => "value") }
+  end
+
+  it "does not include leading whitespace in the name" do
+    the_parse_of("  \t var=value").should == { :main => section_containing(:var => "value") }
+  end
+
+  it "skips lines that are commented out" do
+    the_parse_of("#var = value").should == { :main => section_containing(NOTHING) }
+  end
+
+  it "skips lines that are entirely whitespace" do
+    the_parse_of("   \t ").should == { :main => section_containing(NOTHING) }
+  end
+
+  it "errors when a line is not a known form" do
+    expect { the_parse_of("unknown") }.to raise_error Puppet::Settings::ParseError, /Could not match line/
+  end
+
+  it "stores file meta information in the _meta section" do
+    the_parse_of("var = value { owner = me, group = you, mode = 0666 }").should ==
+      { :main => section_containing(:var => "value", :meta => { :var => { :owner => "me",
+                                                                          :group => "you",
+                                                                          :mode => "0666" } }) }
+  end
+
+  it "errors when there is unknown meta information" do
+    expect { the_parse_of("var = value { unknown = no }") }.
+      to raise_error ArgumentError, /Invalid file option 'unknown'/
+  end
+
+  it "errors when the mode is not numeric" do
+    expect { the_parse_of("var = value { mode = no }") }.
+      to raise_error ArgumentError, "File modes must be numbers"
+  end
+
+  it "errors when the options are not key-value pairs" do
+    expect { the_parse_of("var = value { mode }") }.
+      to raise_error ArgumentError, "Could not parse 'value { mode }'"
+  end
+
+  it "errors when an application_defaults section is created" do
+    expect { the_parse_of("[application_defaults]") }.
+      to raise_error Puppet::Error,
+        "Illegal section 'application_defaults' in config file #{filename} at line [application_defaults]"
+  end
+
+  it "transforms values with the given function" do
+    config = Puppet::Settings::ConfigFile.new(Proc.new { |value| value + " changed" })
+
+    config.parse_file(filename, "var = value").should == { :main => section_containing(:var => "value changed") }
+  end
+
+  it "does not try to transform an entry named 'mode'" do
+    config = Puppet::Settings::ConfigFile.new(Proc.new { raise "Should not transform" })
+
+    config.parse_file(filename, "mode = value").should == { :main => section_containing(:mode => "value") }
+  end
+end
+

data/spec/unit/settings/file_setting_spec.rb

@@ -9,111 +9,113 @@ describe Puppet::Settings::FileSetting do
 
   include PuppetSpec::Files
 
-  before do
-    @basepath = make_absolute("/somepath")
-  end
+  describe "when controlling permissions" do
+    def settings(wanted_values = {})
+       real_values = {
+        :user => 'root',
+        :group => 'root',
+        :mkusers => false,
+        :service_user_available? => false,
+        :service_group_available? => false
+      }.merge(wanted_values)
 
-  describe "when determining whether the service user should be used" do
-    before do
-      @settings = mock 'settings'
-      @settings.stubs(:[]).with(:mkusers).returns false
-      @settings.stubs(:service_user_available?).returns true
-    end
+      settings = mock("settings")
 
-    it "should be true if the service user is available" do
-      @settings.expects(:service_user_available?).returns true
-      setting = FileSetting.new(:settings => @settings, :owner => "root", :desc => "a setting")
-      setting.should be_use_service_user
-    end
+      settings.stubs(:[]).with(:user).returns real_values[:user]
+      settings.stubs(:[]).with(:group).returns real_values[:group]
+      settings.stubs(:[]).with(:mkusers).returns real_values[:mkusers]
+      settings.stubs(:service_user_available?).returns real_values[:service_user_available?]
+      settings.stubs(:service_group_available?).returns real_values[:service_group_available?]
 
-    it "should be true if 'mkusers' is set" do
-      @settings.expects(:[]).with(:mkusers).returns true
-      setting = FileSetting.new(:settings => @settings, :owner => "root", :desc => "a setting")
-      setting.should be_use_service_user
+      settings
     end
 
-    it "should be false if the service user is not available and 'mkusers' is unset" do
-      setting = FileSetting.new(:settings => @settings, :owner => "root", :desc => "a setting")
-      setting.should be_use_service_user
-    end
-  end
+    context "owner" do
+      it "can always be root" do
+        settings = settings(:user => "the_service", :mkusers => true)
 
-  describe "when setting the owner" do
-    it "should allow the file to be owned by root" do
-      root_owner = lambda { FileSetting.new(:settings => mock("settings"), :owner => "root", :desc => "a setting") }
-      root_owner.should_not raise_error
-    end
+        setting = FileSetting.new(:settings => settings, :owner => "root", :desc => "a setting")
 
-    it "should allow the file to be owned by the service user" do
-      service_owner = lambda { FileSetting.new(:settings => mock("settings"), :owner => "service", :desc => "a setting") }
-      service_owner.should_not raise_error
-    end
+        setting.owner.should == "root"
+      end
 
-    it "should allow the ownership of the file to be unspecified" do
-      no_owner = lambda { FileSetting.new(:settings => mock("settings"), :desc => "a setting") }
-      no_owner.should_not raise_error
-    end
+      it "is the service user if we are making users" do
+        settings = settings(:user => "the_service", :mkusers => true, :service_user_available? => false)
 
-    it "should not allow other owners" do
-      invalid_owner = lambda { FileSetting.new(:settings => mock("settings"), :owner => "invalid", :desc => "a setting") }
-      invalid_owner.should raise_error(FileSetting::SettingError)
-    end
-  end
+        setting = FileSetting.new(:settings => settings, :owner => "service", :desc => "a setting")
 
-  describe "when reading the owner" do
-    it "should be root when the setting specifies root" do
-      setting = FileSetting.new(:settings => mock("settings"), :owner => "root", :desc => "a setting")
-      setting.owner.should == "root"
-    end
+        setting.owner.should == "the_service"
+      end
 
-    it "should be the owner of the service when the setting specifies service and the service user should be used" do
-      settings = mock("settings")
-      settings.stubs(:[]).returns "the_service"
+      it "is the service user if the user is available on the system" do
+        settings = settings(:user => "the_service", :mkusers => false, :service_user_available? => true)
 
-      setting = FileSetting.new(:settings => settings, :owner => "service", :desc => "a setting")
-      setting.expects(:use_service_user?).returns true
-      setting.owner.should == "the_service"
-    end
+        setting = FileSetting.new(:settings => settings, :owner => "service", :desc => "a setting")
 
-    it "should be the root when the setting specifies service and the service user should not be used" do
-      settings = mock("settings")
-      settings.stubs(:[]).returns "the_service"
+        setting.owner.should == "the_service"
+      end
 
-      setting = FileSetting.new(:settings => settings, :owner => "service", :desc => "a setting")
-      setting.expects(:use_service_user?).returns false
-      setting.owner.should == "root"
-    end
+      it "is root when the setting specifies service and the user is not available on the system" do
+        settings = settings(:user => "the_service", :mkusers => false, :service_user_available? => false)
 
-    it "should be nil when the owner is unspecified" do
-      FileSetting.new(:settings => mock("settings"), :desc => "a setting").owner.should be_nil
-    end
-  end
+        setting = FileSetting.new(:settings => settings, :owner => "service", :desc => "a setting")
 
-  describe "when setting the group" do
-    it "should allow the group to be service" do
-      service_group = lambda { FileSetting.new(:settings => mock("settings"), :group => "service", :desc => "a setting") }
-      service_group.should_not raise_error
-    end
+        setting.owner.should == "root"
+      end
 
-    it "should allow the group to be unspecified" do
-      no_group = lambda { FileSetting.new(:settings => mock("settings"), :desc => "a setting") }
-      no_group.should_not raise_error
-    end
+      it "is unspecified when no specific owner is wanted" do
+        FileSetting.new(:settings => settings(), :desc => "a setting").owner.should be_nil
+      end
 
-    it "should not allow invalid groups" do
-      invalid_group = lambda { FileSetting.new(:settings => mock("settings"), :group => "invalid", :desc => "a setting") }
-      invalid_group.should raise_error(FileSetting::SettingError)
+      it "does not allow other owners" do
+        expect { FileSetting.new(:settings => settings(), :desc => "a setting", :name => "testing", :default => "the default", :owner => "invalid") }.
+          to raise_error(FileSetting::SettingError, /The :owner parameter for the setting 'testing' must be either 'root' or 'service'/)
+      end
     end
-  end
 
-  describe "when reading the group" do
-    it "should be service when the setting specifies service" do
-      setting = FileSetting.new(:settings => mock("settings", :[] => "the_service"), :group => "service", :desc => "a setting")
-      setting.group.should == "the_service"
-    end
+    context "group" do
+      it "is unspecified when no specific group is wanted" do
+        setting = FileSetting.new(:settings => settings(), :desc => "a setting")
+
+        setting.group.should be_nil
+      end
+
+      it "is root if root is requested" do
+        settings = settings(:group => "the_group")
+
+        setting = FileSetting.new(:settings => settings, :group => "root", :desc => "a setting")
+
+        setting.group.should == "root"
+      end
+
+      it "is the service group if we are making users" do
+        settings = settings(:group => "the_service", :mkusers => true)
 
-    it "should be nil when the group is unspecified" do
-      FileSetting.new(:settings => mock("settings"), :desc => "a setting").group.should be_nil
+        setting = FileSetting.new(:settings => settings, :group => "service", :desc => "a setting")
+
+        setting.group.should == "the_service"
+      end
+
+      it "is the service user if the group is available on the system" do
+        settings = settings(:group => "the_service", :mkusers => false, :service_group_available? => true)
+
+        setting = FileSetting.new(:settings => settings, :group => "service", :desc => "a setting")
+
+        setting.group.should == "the_service"
+      end
+
+      it "is unspecified when the setting specifies service and the group is not available on the system" do
+        settings = settings(:group => "the_service", :mkusers => false, :service_group_available? => false)
+
+        setting = FileSetting.new(:settings => settings, :group => "service", :desc => "a setting")
+
+        setting.group.should be_nil
+      end
+
+      it "does not allow other groups" do
+        expect { FileSetting.new(:settings => settings(), :group => "invalid", :name => 'testing', :desc => "a setting") }.
+          to raise_error(FileSetting::SettingError, /The :group parameter for the setting 'testing' must be either 'root' or 'service'/)
+      end
     end
   end
 
@@ -123,6 +125,7 @@ describe Puppet::Settings::FileSetting do
 
   describe "when being converted to a resource" do
     before do
+      @basepath = make_absolute("/somepath")
       @settings = mock 'settings'
       @file = Puppet::Settings::FileSetting.new(:settings => @settings, :desc => "eh", :name => :myfile, :section => "mysect")
       @file.stubs(:create_files?).returns true