puppet 3.0.2 → 3.1.0.rc1

data/spec/unit/settings/value_translator_spec.rb

@@ -0,0 +1,77 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+require 'puppet/settings/value_translator'
+
+describe Puppet::Settings::ValueTranslator do
+  let(:translator) { Puppet::Settings::ValueTranslator.new }
+
+  context "booleans" do
+    it "translates strings representing booleans to booleans" do
+      translator['true'].should == true
+      translator['false'].should == false
+    end
+
+    it "translates boolean values into themselves" do
+      translator[true].should == true
+      translator[false].should == false
+    end
+
+    it "leaves a boolean string with whitespace as a string" do
+      translator[' true'].should == " true"
+      translator['true '].should == "true"
+
+      translator[' false'].should == " false"
+      translator['false '].should == "false"
+    end
+  end
+
+  context "numbers" do
+    it "translates integer strings to integers" do
+      translator["1"].should == 1
+      translator["2"].should == 2
+    end
+
+    it "translates numbers starting with a 0 as octal" do
+      translator["011"].should == 9
+    end
+
+    it "leaves hex numbers as strings" do
+      translator["0x11"].should == "0x11"
+    end
+  end
+
+  context "arbitrary strings" do
+    it "translates an empty string as the empty string" do
+      translator[""].should == ""
+    end
+
+
+    it "strips double quotes" do
+      translator['"a string"'].should == 'a string'
+    end
+
+    it "strips single quotes" do
+      translator["'a string'"].should == "a string"
+    end
+
+    it "does not strip preceeding whitespace" do
+      translator[" \ta string"].should == " \ta string"
+    end
+
+    it "strips trailing whitespace" do
+      translator["a string\t "].should == "a string"
+    end
+
+    it "leaves leading quote that is preceeded by whitespace" do
+      translator[" 'a string'"].should == " 'a string"
+    end
+
+    it "leaves trailing quote that is succeeded by whitespace" do
+      translator["'a string' "].should == "a string'"
+    end
+
+    it "leaves quotes that are not at the beginning or end of the string" do
+      translator["a st'\"ring"].should == "a st'\"ring"
+    end
+  end
+end

data/spec/unit/settings_spec.rb

@@ -85,14 +85,6 @@ describe Puppet::Settings do
       @settings.define_settings(:main, PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS)
     end
 
-    it "should fail if someone attempts to initialize app defaults more than once" do
-      @settings.initialize_app_defaults(default_values)
-
-      expect {
-        @settings.initialize_app_defaults(default_values)
-      }.to raise_error(Puppet::DevError)
-    end
-
     it "should fail if the app defaults hash is missing any required values" do
       incomplete_default_values = default_values.reject { |key, _| key == :confdir }
       expect {
@@ -676,6 +668,7 @@ describe Puppet::Settings do
     before do
       @settings = Puppet::Settings.new
       @settings.stubs(:service_user_available?).returns true
+      @settings.stubs(:service_group_available?).returns true
       @file = make_absolute("/some/file")
       @userconfig = make_absolute("/test/userconfigfile")
       @settings.define_settings :section, :user => { :default => "suser", :desc => "doc" }, :group => { :default => "sgroup", :desc => "doc" }
@@ -785,6 +778,33 @@ describe Puppet::Settings do
       @settings.metadata(:myfile).should == {:owner => "suser"}
     end
 
+    it "should support loading metadata (owner, group, or mode) from a run_mode section in the configuration file" do
+      default_values = {}
+      PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS.keys.each do |key|
+        default_values[key] = 'default value'
+      end
+      @settings.define_settings :main, PuppetSpec::Settings::TEST_APP_DEFAULT_DEFINITIONS
+      @settings.define_settings :master, :myfile => { :type => :file, :default => make_absolute("/myfile"), :desc => "a" }
+
+      otherfile = make_absolute("/other/file")
+      text = "[master]
+      myfile = #{otherfile} {mode = 664}
+      "
+      @settings.expects(:read_file).returns(text)
+
+      # will start initialization as user
+      @settings.preferred_run_mode.should == :user
+      @settings.send(:parse_config_files)
+
+      # change app run_mode to master
+      @settings.initialize_app_defaults(default_values.merge(:run_mode => :master))
+      @settings.preferred_run_mode.should == :master
+
+      # initializing the app should have reloaded the metadata based on run_mode
+      @settings[:myfile].should == otherfile
+      @settings.metadata(:myfile).should == {:mode => "664"}
+    end
+
     it "should call hooks associated with values set in the configuration file" do
       values = []
       @settings.define_settings :section, :mysetting => {:default => "defval", :desc => "a", :hook => proc { |v| values << v }}
@@ -1245,6 +1265,7 @@ describe Puppet::Settings do
     before do
       @settings = Puppet::Settings.new
       @settings.stubs(:service_user_available?).returns true
+      @settings.stubs(:service_group_available?).returns true
       @settings.define_settings :main, :noop => { :default => false, :desc => "", :type => :boolean }
       @settings.define_settings :main,
           :maindir => { :type => :directory, :default => make_absolute("/maindir"), :desc => "a" },
@@ -1282,12 +1303,6 @@ describe Puppet::Settings do
       @settings.use(:main, :other)
     end
 
-    it "should ignore tags and schedules when creating files and directories"
-
-    it "should be able to provide all of its parameters in a format compatible with GetOpt::Long" do
-      pending "Not converted from test/unit yet"
-    end
-
     it "should convert the created catalog to a RAL catalog" do
       @catalog = Puppet::Resource::Catalog.new("foo")
       @settings.expects(:to_catalog).with(:main).returns @catalog
@@ -1403,8 +1418,6 @@ describe Puppet::Settings do
           @settings.print_configs
         end
 
-        it "should print a whole bunch of stuff if :configprint = all"
-
         it "should return true after printing" do
           @settings.stubs(:value).with(:configprint).returns("something")
           @settings.stubs(:include?).with("something").returns(true)
@@ -1460,35 +1473,89 @@ describe Puppet::Settings do
   end
 
   describe "when determining if the service user is available" do
+    let(:settings) do
+      settings = Puppet::Settings.new
+      settings.define_settings :main, :user => { :default => nil, :desc => "doc" }
+      settings
+    end
+
+    def a_user_type_for(username)
+      user = mock 'user'
+      Puppet::Type.type(:user).expects(:new).with { |args| args[:name] == username }.returns user
+      user
+    end
+
     it "should return false if there is no user setting" do
-      Puppet::Settings.new.should_not be_service_user_available
+      settings.should_not be_service_user_available
     end
 
     it "should return false if the user provider says the user is missing" do
-      settings = Puppet::Settings.new
-      settings.define_settings :main, :user => { :default => "foo", :desc => "doc" }
-
-      user = mock 'user'
-      user.expects(:exists?).returns false
+      settings[:user] = "foo"
 
-      Puppet::Type.type(:user).expects(:new).with { |args| args[:name] == "foo" }.returns user
+      a_user_type_for("foo").expects(:exists?).returns false
 
       settings.should_not be_service_user_available
     end
 
     it "should return true if the user provider says the user is present" do
-      settings = Puppet::Settings.new
-      settings.define_settings :main, :user => { :default => "foo", :desc => "doc" }
+      settings[:user] = "foo"
 
-      user = mock 'user'
-      user.expects(:exists?).returns true
+      a_user_type_for("foo").expects(:exists?).returns true
 
-      Puppet::Type.type(:user).expects(:new).with { |args| args[:name] == "foo" }.returns user
+      settings.should be_service_user_available
+    end
+
+    it "caches the result of determining if the user is present" do
+      settings[:user] = "foo"
+
+      a_user_type_for("foo").expects(:exists?).returns true
+      settings.should be_service_user_available
 
       settings.should be_service_user_available
     end
+  end
+
+  describe "when determining if the service group is available" do
+    let(:settings) do
+      settings = Puppet::Settings.new
+      settings.define_settings :main, :group => { :default => nil, :desc => "doc" }
+      settings
+    end
 
-    it "should cache the result"
+    def a_group_type_for(groupname)
+      group = mock 'group'
+      Puppet::Type.type(:group).expects(:new).with { |args| args[:name] == groupname }.returns group
+      group
+    end
+
+    it "should return false if there is no group setting" do
+      settings.should_not be_service_group_available
+    end
+
+    it "should return false if the group provider says the group is missing" do
+      settings[:group] = "foo"
+
+      a_group_type_for("foo").expects(:exists?).returns false
+
+      settings.should_not be_service_group_available
+    end
+
+    it "should return true if the group provider says the group is present" do
+      settings[:group] = "foo"
+
+      a_group_type_for("foo").expects(:exists?).returns true
+
+      settings.should be_service_group_available
+    end
+
+    it "caches the result of determining if the group is present" do
+      settings[:group] = "foo"
+
+      a_group_type_for("foo").expects(:exists?).returns true
+      settings.should be_service_group_available
+
+      settings.should be_service_group_available
+    end
   end
 
   describe "#writesub" do

data/spec/unit/type/file/ensure_spec.rb

@@ -1,84 +1,123 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'puppet/type/file/ensure'
 
-property = Puppet::Type.type(:file).attrclass(:ensure)
+describe Puppet::Type::File::Ensure do
+  include PuppetSpec::Files
 
-describe property do
-  before do
-    # Wow that's a messy interface to the resource.
-    @resource = stub 'resource', :[] => nil, :[]= => nil, :property => nil, :newattr => nil, :parameter => nil, :replace? => true
-    @resource.stubs(:[]).returns "foo"
-    @resource.stubs(:[]).with(:path).returns "/my/file"
-    @ensure = property.new :resource => @resource
-  end
+  let(:path) { tmpfile('file_ensure') }
+  let(:resource) { Puppet::Type.type(:file).new(:ensure => 'file', :path => path, :replace => true) }
+  let(:property) { resource.property(:ensure) }
 
   it "should be a subclass of Ensure" do
-    property.superclass.must == Puppet::Property::Ensure
+    described_class.superclass.must == Puppet::Property::Ensure
   end
 
   describe "when retrieving the current state" do
     it "should return :absent if the file does not exist" do
-      @ensure = property.new(:resource => @resource)
-      @resource.expects(:stat).returns nil
+      resource.expects(:stat).returns nil
 
-      @ensure.retrieve.should == :absent
+      property.retrieve.should == :absent
     end
 
     it "should return the current file type if the file exists" do
-      @ensure = property.new(:resource => @resource)
       stat = mock 'stat', :ftype => "directory"
-      @resource.expects(:stat).returns stat
+      resource.expects(:stat).returns stat
 
-      @ensure.retrieve.should == :directory
+      property.retrieve.should == :directory
     end
   end
 
   describe "when testing whether :ensure is in sync" do
-    before do
-      @ensure = property.new(:resource => @resource)
-      @stat = stub 'stat', :ftype => "file"
-    end
-
     it "should always be in sync if replace is 'false' unless the file is missing" do
-      @ensure.should = :file
-      @resource.expects(:replace?).returns false
-      @ensure.safe_insync?(:link).should be_true
+      property.should = :file
+      resource.expects(:replace?).returns false
+      property.safe_insync?(:link).should be_true
     end
 
     it "should be in sync if :ensure is set to :absent and the file does not exist" do
-      @ensure.should = :absent
+      property.should = :absent
 
-      @ensure.must be_safe_insync(:absent)
+      property.must be_safe_insync(:absent)
     end
 
     it "should not be in sync if :ensure is set to :absent and the file exists" do
-      @ensure.should = :absent
+      property.should = :absent
 
-      @ensure.should_not be_safe_insync(:file)
+      property.should_not be_safe_insync(:file)
     end
 
     it "should be in sync if a normal file exists and :ensure is set to :present" do
-      @ensure.should = :present
+      property.should = :present
 
-      @ensure.must be_safe_insync(:file)
+      property.must be_safe_insync(:file)
     end
 
     it "should be in sync if a directory exists and :ensure is set to :present" do
-      @ensure.should = :present
+      property.should = :present
 
-      @ensure.must be_safe_insync(:directory)
+      property.must be_safe_insync(:directory)
     end
 
     it "should be in sync if a symlink exists and :ensure is set to :present" do
-      @ensure.should = :present
+      property.should = :present
 
-      @ensure.must be_safe_insync(:link)
+      property.must be_safe_insync(:link)
     end
 
     it "should not be in sync if :ensure is set to :file and a directory exists" do
-      @ensure.should = :file
+      property.should = :file
+
+      property.should_not be_safe_insync(:directory)
+    end
+  end
+
+  describe "#sync" do
+    context "directory" do
+      before :each do
+        resource[:ensure] = :directory
+      end
+
+      it "should raise if the parent directory doesn't exist" do
+        newpath = File.join(path, 'nonexistentparent', 'newdir')
+        resource[:path] = newpath
+
+        expect {
+          property.sync
+        }.to raise_error(Puppet::Error, /Cannot create #{newpath}; parent directory #{File.dirname(newpath)} does not exist/)
+      end
+
+      it "should accept octal mode as fixnum" do
+        resource[:mode] = 0700
+        resource.expects(:property_fix)
+        Dir.expects(:mkdir).with(path, 0700)
+
+        property.sync
+      end
+
+      it "should accept octal mode as string" do
+        resource[:mode] = "700"
+        resource.expects(:property_fix)
+        Dir.expects(:mkdir).with(path, 0700)
+
+        property.sync
+      end
+
+      it "should accept octal mode as string with leading zero" do
+        resource[:mode] = "0700"
+        resource.expects(:property_fix)
+        Dir.expects(:mkdir).with(path, 0700)
+
+        property.sync
+      end
+
+      it "should accept symbolic mode" do
+        resource[:mode] = "u=rwx,go=x"
+        resource.expects(:property_fix)
+        Dir.expects(:mkdir).with(path, 0711)
 
-      @ensure.should_not be_safe_insync(:directory)
+        property.sync
+      end
     end
   end
 end

data/spec/unit/type/file_spec.rb

@@ -194,32 +194,6 @@ describe Puppet::Type.type(:file) do
     end
   end
 
-  describe "#asuser" do
-    before :each do
-      # Mocha won't let me just stub SUIDManager.asuser to yield and return,
-      # but it will do exactly that if we're not root.
-      Puppet.features.stubs(:root?).returns false
-    end
-
-    it "should return the desired owner if they can write to the parent directory" do
-      file[:owner] = 1001
-      FileTest.stubs(:writable?).with(File.dirname file[:path]).returns true
-
-      file.asuser.should == 1001
-    end
-
-    it "should return nil if the desired owner can't write to the parent directory" do
-      file[:owner] = 1001
-      FileTest.stubs(:writable?).with(File.dirname file[:path]).returns false
-
-      file.asuser.should == nil
-    end
-
-    it "should return nil if not managing owner" do
-      file.asuser.should == nil
-    end
-  end
-
   describe "#bucket" do
     it "should return nil if backup is off" do
       file[:backup] = false
@@ -288,48 +262,6 @@ describe Puppet::Type.type(:file) do
     end
   end
 
-  describe "#bucket" do
-    it "should return nil if backup is off" do
-      file[:backup] = false
-      file.bucket.should == nil
-    end
-
-    it "should return nil if using a file extension for backup" do
-      file[:backup] = '.backup'
-
-      file.bucket.should == nil
-    end
-
-    it "should return the default filebucket if using the 'puppet' filebucket" do
-      file[:backup] = 'puppet'
-      bucket = stub('bucket')
-      file.stubs(:default_bucket).returns bucket
-
-      file.bucket.should == bucket
-    end
-
-    it "should fail if using a remote filebucket and no catalog exists" do
-      file.catalog = nil
-      file[:backup] = 'my_bucket'
-
-      expect { file.bucket }.to raise_error(Puppet::Error, "Can not find filebucket for backups without a catalog")
-    end
-
-    it "should fail if the specified filebucket isn't in the catalog" do
-      file[:backup] = 'my_bucket'
-
-      expect { file.bucket }.to raise_error(Puppet::Error, "Could not find filebucket my_bucket specified in backup")
-    end
-
-    it "should use the specified filebucket if it is in the catalog" do
-      file[:backup] = 'my_bucket'
-      filebucket = Puppet::Type.type(:filebucket).new(:name => 'my_bucket')
-      catalog.add_resource(filebucket)
-
-      file.bucket.should == filebucket.bucket
-    end
-  end
-
   describe "#exist?" do
     it "should be considered existent if it can be stat'ed" do
       file.expects(:stat).returns mock('stat')