puppet 0.24.9 → 0.25.0

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

@@ -13,7 +13,7 @@ describe provider_class do
     include PuppetTest::FileParsing
 
     before :each do
-        @sshauthkey_class = Puppet.type(:ssh_authorized_key)
+        @sshauthkey_class = Puppet::Type.type(:ssh_authorized_key)
         @provider = @sshauthkey_class.provider(:parsed)
     end
 
@@ -120,7 +120,71 @@ describe provider_class do
             end
 
             it "should chmod the key file to 0600" do
-                File.chmod(0600, File.expand_path("~nobody/.ssh/authorized_keys"))
+                File.expects(:chmod).with(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
+
+    end
+end
+
+describe provider_class do
+    before :each do
+        @resource = stub("resource", :name => "foo")
+        @resource.stubs(:[]).returns "foo"
+        @provider = provider_class.new(@resource)
+    end
+
+    describe "when flushing" do
+        before :each do
+            # Stub file and directory operations
+            Dir.stubs(:mkdir)
+            File.stubs(:chmod)
+            File.stubs(:chown)
+        end
+
+        describe "and a user has been specified" do
+            before :each do
+                @resource.stubs(:should).with(:user).returns "nobody"
+                @resource.stubs(:should).with(:target).returns nil
+           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.expects(:chmod).with(0600, File.expand_path("~nobody/.ssh/authorized_keys"))
                 @provider.flush
             end
         end

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

@@ -27,7 +27,7 @@ describe provider_class do
     it "should be able to manage passwords" do
         provider_class.should be_manages_passwords
     end
-    
+
     it "should use the ldap group provider to convert group names to numbers" do
         provider = provider_class.new(:name => "foo")
         Puppet::Type.type(:group).provider(:ldap).expects(:name2id).with("bar").returns 10

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

@@ -239,7 +239,7 @@ describe provider_class do
             File.stubs(:rename)
             @provider.password=("hashedpassword")
         end
-        
+
         it "should rename the /etc/shadow_tmp to /etc/shadow" do
             File.stubs(:open).with("/etc/shadow", "r")
             File.expects(:rename).with("/etc/shadow_tmp", "/etc/shadow")

data/spec/unit/provider/zfs/solaris.rb

@@ -12,6 +12,18 @@ describe provider_class do
         @provider = provider_class.new(@resource)
     end
 
+    it "should have a create method" do
+        @provider.should respond_to(:create)
+    end
+
+    it "should have a destroy method" do
+        @provider.should respond_to(:destroy)
+    end
+
+    it "should have an exists? method" do
+        @provider.should respond_to(:exists?)
+    end
+
     describe "when calling add_properties" do
         it "should add -o and the key=value for each properties with a value" do
             @resource.stubs(:[]).with(:quota).returns ""
@@ -37,21 +49,21 @@ describe provider_class do
         end
     end
 
-    describe "when calling delete" do
+    describe "when calling destroy" do
         it "should call zfs with :destroy and this zfs" do
             @provider.expects(:zfs).with(:destroy, @resource[:name])
-            @provider.delete
+            @provider.destroy
         end
     end
-   
+
     describe "when calling exist?" do
         it "should call zfs with :list" do
             #return stuff because we have to slice and dice it
             @provider.expects(:zfs).with(:list).returns("NAME USED AVAIL REFER MOUNTPOINT\nmyzfs 100K 27.4M /myzfs")
             @provider.exists?
         end
-        
-        it "should return true if returned values match the name" do 
+
+        it "should return true if returned values match the name" do
             @provider.stubs(:zfs).with(:list).returns("NAME USED AVAIL REFER MOUNTPOINT\n#{@resource[:name]} 100K 27.4M /myzfs")
             @provider.exists?.should == true
         end
@@ -60,7 +72,7 @@ describe provider_class do
             @provider.stubs(:zfs).with(:list).returns("no soup for you")
             @provider.exists?.should == false
         end
-            
+
     end
 
     [:mountpoint, :compression, :copies, :quota, :reservation, :sharenfs, :snapdir].each do |prop|

data/spec/unit/provider/zone/solaris.rb

@@ -25,7 +25,7 @@ describe provider_class do
             @provider.expects(:zoneadm)
             @provider.install
         end
-        
+
         it "should just install if there are no install args" do
             @resource.stubs(:[]).with(:install_args).returns(nil)
             @provider.expects(:zoneadm).with(:install)

data/spec/unit/rails.rb

@@ -13,22 +13,23 @@ describe Puppet::Rails, "when initializing any connection" do
         Logger.stubs(:new).returns(@logger)
 
         ActiveRecord::Base.stubs(:logger).returns(@logger)
+        ActiveRecord::Base.stubs(:connected?).returns(false)
     end
 
     it "should use settings" do
         Puppet.settings.expects(:use).with(:main, :rails, :puppetmasterd)
-        
+
         Puppet::Rails.connect
     end
-    
+
     it "should set up a logger with the appropriate Rails log file" do
         logger = mock 'logger'
         Logger.expects(:new).with(Puppet[:railslog]).returns(logger)
         ActiveRecord::Base.expects(:logger=).with(logger)
-        
+
         Puppet::Rails.connect
     end
-    
+
     it "should set the log level to whatever the value is in the settings" do
         Puppet.settings.stubs(:use)
         Puppet.settings.stubs(:value).with(:rails_loglevel).returns("debug")
@@ -38,42 +39,35 @@ describe Puppet::Rails, "when initializing any connection" do
         ActiveRecord::Base.stubs(:logger).returns(logger)
         logger.expects(:level=).with(Logger::DEBUG)
 
-        ActiveRecord::Base.stubs(:allow_concurrency=)
         ActiveRecord::Base.stubs(:verify_active_connections!)
         ActiveRecord::Base.stubs(:establish_connection)
         Puppet::Rails.stubs(:database_arguments)
-        
-        Puppet::Rails.connect
-    end
-    
-    it "should set ActiveRecord::Base.allow_concurrency" do
-        ActiveRecord::Base.expects(:allow_concurrency=).with(true)
-        
+
         Puppet::Rails.connect
     end
-    
+
     it "should call ActiveRecord::Base.verify_active_connections!" do
         ActiveRecord::Base.expects(:verify_active_connections!)
-        
+
         Puppet::Rails.connect
     end
-    
+
     it "should call ActiveRecord::Base.establish_connection with database_arguments" do
         Puppet::Rails.expects(:database_arguments)
         ActiveRecord::Base.expects(:establish_connection)
-        
+
         Puppet::Rails.connect
     end
 end
 
 describe Puppet::Rails, "when initializing a sqlite3 connection" do
-    confine Puppet.features.rails? => "Cannot test without ActiveRecord" 
+    confine "Cannot test without ActiveRecord" => Puppet.features.rails?
 
     it "should provide the adapter, log_level, and dbfile arguments" do
         Puppet.settings.expects(:value).with(:dbadapter).returns("sqlite3")
         Puppet.settings.expects(:value).with(:rails_loglevel).returns("testlevel")
         Puppet.settings.expects(:value).with(:dblocation).returns("testlocation")
-        
+
         Puppet::Rails.database_arguments.should == {
             :adapter => "sqlite3",
             :log_level => "testlevel",
@@ -83,7 +77,7 @@ describe Puppet::Rails, "when initializing a sqlite3 connection" do
 end
 
 describe Puppet::Rails, "when initializing a mysql or postgresql connection" do
-    confine Puppet.features.rails? => "Cannot test without ActiveRecord" 
+    confine "Cannot test without ActiveRecord" => Puppet.features.rails?
 
     it "should provide the adapter, log_level, and host, username, password, and database arguments" do
         Puppet.settings.stubs(:value).with(:dbadapter).returns("mysql")
@@ -93,7 +87,7 @@ describe Puppet::Rails, "when initializing a mysql or postgresql connection" do
         Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
         Puppet.settings.stubs(:value).with(:dbname).returns("testname")
         Puppet.settings.stubs(:value).with(:dbsocket).returns("")
-        
+
         Puppet::Rails.database_arguments.should == {
             :adapter => "mysql",
             :log_level => "testlevel",
@@ -103,7 +97,7 @@ describe Puppet::Rails, "when initializing a mysql or postgresql connection" do
             :database => "testname"
         }
     end
-    
+
     it "should provide the adapter, log_level, and host, username, password, database, and socket arguments" do
         Puppet.settings.stubs(:value).with(:dbadapter).returns("mysql")
         Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
@@ -112,7 +106,7 @@ describe Puppet::Rails, "when initializing a mysql or postgresql connection" do
         Puppet.settings.stubs(:value).with(:dbpassword).returns("testpassword")
         Puppet.settings.stubs(:value).with(:dbname).returns("testname")
         Puppet.settings.stubs(:value).with(:dbsocket).returns("testsocket")
-        
+
         Puppet::Rails.database_arguments.should == {
             :adapter => "mysql",
             :log_level => "testlevel",

data/spec/unit/rails/host.rb

@@ -0,0 +1,163 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "Puppet::Rails::Host" do
+    confine "Cannot test without ActiveRecord" => Puppet.features.rails?
+
+    def column(name, type)
+        ActiveRecord::ConnectionAdapters::Column.new(name, nil, type, false)
+    end
+
+    before do
+        require 'puppet/rails/host'
+
+        # Stub this so we don't need access to the DB.
+        Puppet::Rails::Host.stubs(:columns).returns([column("name", "string"), column("environment", "string"), column("ip", "string")])
+
+        @node = Puppet::Node.new("foo")
+        @node.environment = "production"
+        @node.ipaddress = "127.0.0.1"
+
+        @host = stub 'host', :environment= => nil, :ip= => nil
+    end
+
+    describe "when converting a Puppet::Node instance into a Rails instance" do
+        it "should modify any existing instance in the database" do
+            Puppet::Rails::Host.expects(:find_by_name).with("foo").returns @host
+
+            Puppet::Rails::Host.from_puppet(@node)
+        end
+
+        it "should create a new instance in the database if none can be found" do
+            Puppet::Rails::Host.expects(:find_by_name).with("foo").returns nil
+            Puppet::Rails::Host.expects(:new).with(:name => "foo").returns @host
+
+            Puppet::Rails::Host.from_puppet(@node)
+        end
+
+        it "should copy the environment from the Puppet instance" do
+            Puppet::Rails::Host.expects(:find_by_name).with("foo").returns @host
+
+            @node.environment = "production"
+            @host.expects(:environment=).with "production"
+
+            Puppet::Rails::Host.from_puppet(@node)
+        end
+
+        it "should copy the ipaddress from the Puppet instance" do
+            Puppet::Rails::Host.expects(:find_by_name).with("foo").returns @host
+
+            @node.ipaddress = "192.168.0.1"
+            @host.expects(:ip=).with "192.168.0.1"
+
+            Puppet::Rails::Host.from_puppet(@node)
+        end
+
+        it "should not save the Rails instance" do
+            Puppet::Rails::Host.expects(:find_by_name).with("foo").returns @host
+
+            @host.expects(:save).never
+
+            Puppet::Rails::Host.from_puppet(@node)
+        end
+    end
+
+    describe "when converting a Puppet::Rails::Host instance into a Puppet::Node instance" do
+        before do
+            @host = Puppet::Rails::Host.new(:name => "foo", :environment => "production", :ip => "127.0.0.1")
+            @node = Puppet::Node.new("foo")
+            Puppet::Node.stubs(:new).with("foo").returns @node
+        end
+
+        it "should create a new instance with the correct name" do
+            Puppet::Node.expects(:new).with("foo").returns @node
+
+            @host.to_puppet
+        end
+
+        it "should copy the environment from the Rails instance" do
+            @host.environment = "prod"
+            @node.expects(:environment=).with "prod"
+            @host.to_puppet
+        end
+
+        it "should copy the ipaddress from the Rails instance" do
+            @host.ip = "192.168.0.1"
+            @node.expects(:ipaddress=).with "192.168.0.1"
+            @host.to_puppet
+        end
+    end
+
+    describe "when merging catalog resources and database resources" do
+        before :each do
+            Puppet.settings.stubs(:[]).with(:thin_storeconfigs).returns(false)
+            @resource1 = stub_everything 'res1'
+            @resource2 = stub_everything 'res2'
+            @resources = [ @resource1, @resource2 ]
+
+            @dbresource1 = stub_everything 'dbres1'
+            @dbresource2 = stub_everything 'dbres2'
+            @dbresources = { 1 => @dbresource1, 2 => @dbresource2 }
+
+            @host = Puppet::Rails::Host.new(:name => "foo", :environment => "production", :ip => "127.0.0.1")
+            @host.stubs(:find_resources).returns(@dbresources)
+            @host.stubs(:find_resources_parameters_tags)
+            @host.stubs(:compare_to_catalog)
+            @host.stubs(:id).returns(1)
+        end
+
+        it "should find all database resources" do
+            @host.expects(:find_resources)
+
+            @host.merge_resources(@resources)
+        end
+
+        it "should find all paramaters and tags for those database resources" do
+            @host.expects(:find_resources_parameters_tags).with(@dbresources)
+
+            @host.merge_resources(@resources)
+        end
+
+        it "should compare all database resources to catalog" do
+            @host.expects(:compare_to_catalog).with(@dbresources, @resources)
+
+            @host.merge_resources(@resources)
+        end
+
+        it "should compare only exported resources in thin_storeconfigs mode" do
+            Puppet.settings.stubs(:[]).with(:thin_storeconfigs).returns(true)
+            @resource1.stubs(:exported?).returns(true)
+
+            @host.expects(:compare_to_catalog).with(@dbresources, [ @resource1 ])
+
+            @host.merge_resources(@resources)
+        end
+    end
+
+    describe "when searching the database for host resources" do
+        before :each do
+            Puppet.settings.stubs(:[]).with(:thin_storeconfigs).returns(false)
+            @resource1 = stub_everything 'res1', :id => 1
+            @resource2 = stub_everything 'res2', :id => 2
+            @resources = [ @resource1, @resource2 ]
+
+            @dbresources = stub 'resources'
+            @dbresources.stubs(:find).returns(@resources)
+
+            @host = Puppet::Rails::Host.new(:name => "foo", :environment => "production", :ip => "127.0.0.1")
+            @host.stubs(:resources).returns(@dbresources)
+        end
+
+        it "should return a hash keyed by id of all resources" do
+            @host.find_resources.should == { 1 => @resource1, 2 => @resource2 }
+        end
+
+        it "should return a hash keyed by id of only exported resources in thin_storeconfigs mode" do
+            Puppet.settings.stubs(:[]).with(:thin_storeconfigs).returns(true)
+            @dbresources.expects(:find).with { |*h| h[1][:conditions] == { :exported => true } }.returns([])
+
+            @host.find_resources
+        end
+    end
+end

data/spec/unit/rails/param_value.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "Puppet::Rails::ParamValue" do
+    confine "Cannot test without ActiveRecord" => Puppet.features.rails?
+
+    def column(name, type)
+        ActiveRecord::ConnectionAdapters::Column.new(name, nil, type, false)
+    end
+
+    before do
+        require 'puppet/rails/param_value'
+
+        name = stub 'param_name', :name => "foo"
+
+        # Stub this so we don't need access to the DB.
+        Puppet::Rails::ParamValue.stubs(:columns).returns([column("value", "string")])
+        Puppet::Rails::ParamName.stubs(:find_or_create_by_name).returns(name)
+    end
+
+    describe "when creating initial parameter values" do
+        it "should return an array of hashes" do
+            Puppet::Rails::ParamValue.from_parser_param(:myparam, %w{a b})[0].should be_instance_of(Hash)
+        end
+
+        it "should return hashes for each value with the parameter name set as the ParamName instance" do
+            name = stub 'param_name', :name => "foo"
+            Puppet::Rails::ParamName.expects(:find_or_create_by_name).returns(name)
+
+            result = Puppet::Rails::ParamValue.from_parser_param(:myparam, "a")[0]
+            result[:value].should == "a"
+            result[:param_name].should == name
+        end
+
+        it "should return an array of hashes even when only one parameter is provided" do
+            Puppet::Rails::ParamValue.from_parser_param(:myparam, "a")[0].should be_instance_of(Hash)
+        end
+
+        it "should convert all arguments into strings" do
+            Puppet::Rails::ParamValue.from_parser_param(:myparam, 50)[0][:value].should == "50"
+        end
+
+        it "should not convert Resource References into strings" do
+            ref = Puppet::Resource::Reference.new(:file, "/file")
+            Puppet::Rails::ParamValue.from_parser_param(:myparam, ref)[0][:value].should == ref
+        end
+    end
+end