puppet 0.24.7 → 0.24.8

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

@@ -130,6 +130,7 @@ describe provider_class do
     describe provider_class, " when modifying the filesystem tab" do
         include ParsedMountTesting
         before do
+            Puppet.settings.stubs(:use)
             # Never write to disk, only to RAM.
             @provider_class.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
 

data/spec/unit/provider/naginator.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/provider/naginator'
+
+describe Puppet::Provider::Naginator do
+    before do
+        @resource_type = stub 'resource_type', :name => :nagios_test
+        @class = Class.new(Puppet::Provider::Naginator)
+
+        @class.stubs(:resource_type).returns @resource_type
+    end
+
+    it "should be able to look up the associated Nagios type" do
+        nagios_type = mock "nagios_type"
+        nagios_type.stubs :attr_accessor
+        Nagios::Base.expects(:type).with(:test).returns nagios_type
+
+        @class.nagios_type.should equal(nagios_type)
+    end
+
+    it "should use the Nagios type to determine whether an attribute is valid" do
+        nagios_type = mock "nagios_type"
+        nagios_type.stubs :attr_accessor
+        Nagios::Base.expects(:type).with(:test).returns nagios_type
+
+        nagios_type.expects(:parameters).returns [:foo, :bar]
+
+        @class.valid_attr?(:test, :foo).should be_true
+    end
+
+    it "should use Naginator to parse configuration snippets" do
+        parser = mock 'parser'
+        parser.expects(:parse).with("my text").returns "my instances"
+        Nagios::Parser.expects(:new).returns(parser)
+
+        @class.parse("my text").should == "my instances"
+    end
+
+    it "should join Nagios::Base records with '\\n' when asked to convert them to text" do
+        @class.expects(:header).returns "myheader\n"
+
+        @class.to_file([:one, :two]).should == "myheader\none\ntwo"
+    end
+
+    it "should be able to prefetch instance from configuration files" do
+        @class.should respond_to(:prefetch)
+    end
+
+    it "should be able to generate a list of instances" do
+        @class.should respond_to(:instances)
+    end
+
+    it "should never skip records" do
+        @class.should_not be_skip_record("foo")
+    end
+end

data/spec/unit/provider/parsedfile.rb

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/provider/parsedfile'
+
+# Most of the tests for this are still in test/ral/provider/parsedfile.rb.
+describe Puppet::Provider::ParsedFile do
+    before do
+        @class = Class.new(Puppet::Provider::ParsedFile)
+    end
+
+    describe "when looking up records loaded from disk" do
+        it "should return nil if no records have been loaded" do
+            @class.record?("foo").should be_nil
+        end
+    end
+
+    describe "when generating a list of instances" do
+        it "should return an instance for each record parsed from all of the registered targets" do
+            @class.expects(:targets).returns %w{/one /two}
+            @class.stubs(:skip_record?).returns false
+            one = [:uno1, :uno2]
+            two = [:dos1, :dos2]
+            @class.expects(:prefetch_target).with("/one").returns one
+            @class.expects(:prefetch_target).with("/two").returns two
+
+            results = []
+            (one + two).each do |inst|
+                results << inst.to_s + "_instance"
+                @class.expects(:new).with(inst).returns(results[-1])
+            end
+
+            @class.instances.should == results
+        end
+
+        it "should skip specified records" do
+            @class.expects(:targets).returns %w{/one}
+            @class.expects(:skip_record?).with(:uno).returns false
+            @class.expects(:skip_record?).with(:dos).returns true
+            one = [:uno, :dos]
+            @class.expects(:prefetch_target).returns one
+
+            @class.expects(:new).with(:uno).returns "eh"
+            @class.expects(:new).with(:dos).never
+
+            @class.instances
+        end
+    end
+
+    describe "when flushing a file's records to disk" do
+        before do
+            # This way we start with some @records, like we would in real life.
+            @class.stubs(:retrieve).returns []
+            @class.default_target = "/foo/bar"
+            @class.initvars
+            @class.prefetch
+
+            @filetype = Puppet::Util::FileType.filetype(:flat).new("/my/file")
+            Puppet::Util::FileType.filetype(:flat).stubs(:new).with("/my/file").returns @filetype
+
+            @filetype.stubs(:write)
+        end
+
+        it "should back up the file being written if the filetype can be backed up" do
+            @filetype.expects(:backup)
+
+            @class.flush_target("/my/file")
+        end
+
+        it "should not try to back up the file if the filetype cannot be backed up" do
+            @filetype = Puppet::Util::FileType.filetype(:ram).new("/my/file")
+            Puppet::Util::FileType.filetype(:flat).expects(:new).returns @filetype
+
+            @filetype.stubs(:write)
+
+            @class.flush_target("/my/file")
+        end
+
+        it "should not back up the file more than once between calls to 'prefetch'" do
+            @filetype.expects(:backup).once
+
+            @class.flush_target("/my/file")
+            @class.flush_target("/my/file")
+        end
+
+        it "should back the file up again once the file has been reread" do
+            @filetype.expects(:backup).times(2)
+
+            @class.flush_target("/my/file")
+            @class.prefetch
+            @class.flush_target("/my/file")
+        end
+    end
+end

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

@@ -62,9 +62,17 @@ describe provider_class do
     
     describe "when checking status" do
         it "should call the external command 'launchctl list' once" do
-            @provider.expects(:launchctl).with(:list, @resource[:name]).returns(:running).once
+            @provider.expects(:launchctl).with(:list).returns("rotating-strawberry-madonnas")
             @provider.status
         end
+        it "should return stopped if not listed in launchctl list output" do
+            @provider.stubs(:launchctl).with(:list).returns("rotating-strawberry-madonnas")
+            @provider.status.should == :stopped
+        end
+        it "should return running if listed in launchctl list output" do
+            @provider.stubs(:launchctl).with(:list).returns(@joblabel)
+            @provider.status.should == :running
+        end
     end
     
     describe "when starting the service" do

data/spec/unit/provider/ssh_authorized_key/parsed.rb

@@ -72,31 +72,75 @@ describe provider_class do
         genkey(key).should == "from=\"192.168.1.1\",no-pty,no-X11-forwarding ssh-rsa AAAAfsfddsjldjgksdflgkjsfdlgkj root@localhost\n"
     end
 
-    it "should prefetch ~user/.ssh/authorized_keys when user is given" do
-        key = Puppet::Type.type(:ssh_authorized_key).create(
-            :name => "Test",
-            :key => "AA",
-            :type => "rsa",
-            :ensure => :present,
-            :user => "root")
-        prov = @provider.new key
+    it "'s parse_options method should be able to parse options containing commas" do
+        options = %w{from="host1.reductlivelabs.com,host.reductivelabs.com" command="/usr/local/bin/run" ssh-pty}
+        optionstr = options.join(", ")
 
-        prov.prefetch
-        prov.target.should == File.expand_path("~root/.ssh/authorized_keys")
+        @provider.parse_options(optionstr).should == options
     end
+end
 
-    it "should create destination dir" do
-        # No idea how to test the flush method
+describe provider_class do
+    before :each do
+        @resource = stub("resource", :name => "foo")
+        @resource.stubs(:[]).returns "foo"
+        @provider = provider_class.new(@resource)
     end
 
-    it "should set correct default permissions" do
-        # No idea how to test the flush method
-    end
+    describe "when flushing" do
+        before :each do
+            # Stub file and directory operations
+            Dir.stubs(:mkdir)
+            File.stubs(:chmod)
+            File.stubs(:chown)
+        end
 
-    it "'s parse_options method should be able to parse options containing commas" do
-        options = %w{from="host1.reductlivelabs.com,host.reductivelabs.com" command="/usr/local/bin/run" ssh-pty}
-        optionstr = options.join(", ")
+        describe "and a user has been specified" do
+            before :each do
+                @resource.stubs(:should).with(:user).returns "nobody"
+                target = File.expand_path("~nobody/.ssh/authorized_keys")
+                @resource.stubs(:should).with(:target).returns target
+           end
+
+            it "should create the directory" do
+                Dir.expects(:mkdir).with(File.expand_path("~nobody/.ssh"), 0700)
+                @provider.flush
+            end
+
+            it "should chown the directory to the user" do
+                uid = Puppet::Util.uid("nobody")
+                File.expects(:chown).with(uid, nil, File.expand_path("~nobody/.ssh"))
+                @provider.flush
+            end
+
+            it "should chown the key file to the user" do
+                uid = Puppet::Util.uid("nobody")
+                File.expects(:chown).with(uid, nil, File.expand_path("~nobody/.ssh/authorized_keys"))
+                @provider.flush
+            end
+
+            it "should chmod the key file to 0600" do
+                File.chmod(0600, File.expand_path("~nobody/.ssh/authorized_keys"))
+                @provider.flush
+            end
+        end
+
+        describe "and a target has been specified" do
+            before :each do
+                @resource.stubs(:should).with(:user).returns nil
+                @resource.stubs(:should).with(:target).returns "/tmp/.ssh/authorized_keys"
+            end
+
+            it "should make the directory" do
+                Dir.expects(:mkdir).with("/tmp/.ssh", 0755)
+                @provider.flush
+            end
+
+            it "should chmod the key file to 0644" do
+                File.expects(:chmod).with(0644, "/tmp/.ssh/authorized_keys")
+                @provider.flush
+            end
+        end
 
-        @provider.parse_options(optionstr).should == options
     end
 end

data/spec/unit/rails.rb

@@ -7,6 +7,7 @@ describe Puppet::Rails, "when initializing any connection" do
     confine "Cannot test without ActiveRecord" => Puppet.features.rails?
 
     before do
+        Puppet.settings.stubs(:use)
         @logger = mock 'logger'
         @logger.stub_everything
         Logger.stubs(:new).returns(@logger)

data/spec/unit/{other/transaction.rb → transaction.rb}

@@ -1,9 +1,24 @@
 #!/usr/bin/env ruby
 
-require File.dirname(__FILE__) + '/../../spec_helper'
+require File.dirname(__FILE__) + '/../spec_helper'
 
 require 'puppet/transaction'
 
+describe Puppet::Transaction do
+    it "should match resources by name, not title, when prefetching" do
+        @catalog = Puppet::Node::Catalog.new
+        @transaction = Puppet::Transaction.new(@catalog)
+
+        # Have both a title and name
+        resource = Puppet::Type.type(:sshkey).create :title => "foo", :name => "bar", :type => :dsa, :key => "eh"
+        @catalog.add_resource resource
+
+        resource.provider.class.expects(:prefetch).with("bar" => resource)
+
+        @transaction.prefetch
+    end
+end
+
 describe Puppet::Transaction, " when determining tags" do
     before do
         @config = Puppet::Node::Catalog.new

data/spec/unit/type/file.rb

@@ -4,6 +4,8 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe Puppet::Type.type(:file) do
     before do
+        Puppet.settings.stubs(:use)
+
         @path = Tempfile.new("puppetspec")
         @path.close!()
         @path = @path.path

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

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+
+property = Puppet::Type.type(:file).attrclass(:content)
+
+describe property do
+    before do
+        @resource = stub 'resource', :line => "foo", :file => "bar", :replace? => true
+        @resource.stubs(:[]).returns "foo"
+        @resource.stubs(:[]).with(:path).returns "/my/file"
+        @content = property.new :resource => @resource
+    end
+
+    it "should not include current contents when producing a change log" do
+        @content.change_to_s("current_content", "desired").should_not be_include("current_content")
+    end
+
+    it "should not include desired contents when producing a change log" do
+        @content.change_to_s("current", "desired_content").should_not be_include("desired_content")
+    end
+
+    it "should not include the content when converting current content to a string" do
+        @content.is_to_s("my_content").should_not be_include("my_content")
+    end
+
+    it "should not include the content when converting desired content to a string" do
+        @content.should_to_s("my_content").should_not be_include("my_content")
+    end
+end

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

@@ -74,6 +74,12 @@ Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f
             @sel.sync
         end
 
+        it "should do nothing for insync? if no SELinux support" do
+            @sel.should = %{newcontext}
+            @sel.expects(:selinux_support?).returns false
+            @sel.insync?("oldcontext").should == true
+        end
+
         after do
             Puppet::Type.type(:file).clear
         end