puppet 0.24.6 → 0.24.7

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

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+provider_class = Puppet::Type.type(:zone).provider(:solaris)
+
+describe provider_class do
+    before do
+        @resource = stub("resource", :name => "mypool")
+        @resource.stubs(:[]).returns "shouldvalue"
+        @provider = provider_class.new(@resource)
+    end
+
+    describe "when calling configure" do
+        it "should add the create args to the create str" do
+            @resource.stubs(:properties).returns([])
+            @resource.stubs(:[]).with(:create_args).returns("create_args")
+            @provider.expects(:setconfig).with("create -b create_args\nset zonepath=shouldvalue\ncommit\n")
+            @provider.configure
+        end
+    end
+
+    describe "when installing" do
+        it "should call zoneadm" 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)
+            @provider.install
+        end
+
+        it "should add the install args to the command if they exist" do
+            @resource.stubs(:[]).with(:install_args).returns("install args")
+            @provider.expects(:zoneadm).with(:install, ["install", "args"])
+            @provider.install
+        end
+    end
+
+end

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

@@ -0,0 +1,179 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+provider_class = Puppet::Type.type(:zpool).provider(:solaris)
+
+describe provider_class do
+    before do
+        @resource = stub("resource", :name => "mypool")
+        @resource.stubs(:[]).returns "shouldvalue"
+        @provider = provider_class.new(@resource)
+    end
+
+    describe "when getting the instance" do
+        it "should call process_zpool_data with the result of get_pool_data only once" do
+            @provider.stubs(:get_pool_data).returns(["foo", "disk"])
+            @provider.expects(:process_zpool_data).with(["foo", "disk"]).returns("stuff").once
+            @provider.current_pool
+            @provider.current_pool
+        end
+    end
+
+    describe "when calling flush" do
+        it "should need to reload the pool" do
+            @provider.stubs(:get_pool_data)
+            @provider.expects(:process_zpool_data).returns("stuff").times(2)
+            @provider.current_pool
+            @provider.flush
+            @provider.current_pool
+        end
+    end
+
+    describe "when procesing zpool data" do
+        before do
+            @zpool_data = ["foo", "disk"]
+        end
+
+        describe "when there is no data" do
+            it "should return a hash with ensure=>:absent" do
+                @provider.process_zpool_data([])[:ensure].should == :absent
+            end
+        end
+
+        describe "when there is a spare" do
+            it "should add the spare disk to the hash" do
+                @zpool_data += ["spares", "spare_disk"]
+                @provider.process_zpool_data(@zpool_data)[:spare].should == ["spare_disk"]
+            end
+        end
+
+        describe "when there are two spares" do
+            it "should add the spare disk to the hash as a single string" do
+                @zpool_data += ["spares", "spare_disk", "spare_disk2"]
+                @provider.process_zpool_data(@zpool_data)[:spare].should == ["spare_disk spare_disk2"]
+            end
+        end
+
+        describe "when there is a log" do
+            it "should add the log disk to the hash" do
+                @zpool_data += ["logs", "log_disk"]
+                @provider.process_zpool_data(@zpool_data)[:log].should == ["log_disk"]
+            end
+        end
+
+        describe "when there are two logs" do
+            it "should add the log disks to the hash as a single string" do
+                @zpool_data += ["spares", "spare_disk", "spare_disk2"]
+                @provider.process_zpool_data(@zpool_data)[:spare].should == ["spare_disk spare_disk2"]
+            end
+        end
+
+        describe "when the vdev is a single mirror" do
+            it "should call create_multi_array with mirror" do
+                @zpool_data = ["mirrorpool", "mirror", "disk1", "disk2"]
+                @provider.process_zpool_data(@zpool_data)[:mirror].should == ["disk1 disk2"]
+            end
+        end
+
+        describe "when the vdev is a double mirror" do
+            it "should call create_multi_array with mirror" do
+                @zpool_data = ["mirrorpool", "mirror", "disk1", "disk2", "mirror", "disk3", "disk4"]
+                @provider.process_zpool_data(@zpool_data)[:mirror].should == ["disk1 disk2", "disk3 disk4"]
+            end
+        end
+
+        describe "when the vdev is a raidz1" do
+            it "should call create_multi_array with raidz1" do
+                @zpool_data = ["mirrorpool", "raidz1", "disk1", "disk2"]
+                @provider.process_zpool_data(@zpool_data)[:raidz].should == ["disk1 disk2"]
+            end
+        end
+
+        describe "when the vdev is a raidz2" do
+            it "should call create_multi_array with raidz2 and set the raid_parity" do
+                @zpool_data = ["mirrorpool", "raidz2", "disk1", "disk2"]
+                pool = @provider.process_zpool_data(@zpool_data)
+                pool[:raidz].should == ["disk1 disk2"]
+                pool[:raid_parity].should == "raidz2"
+            end
+        end
+    end
+
+    describe "when calling the getters and setters" do
+        [:disk, :mirror, :raidz, :log, :spare].each do |field|
+            describe "when calling %s" % field do
+                it "should get the %s value from the current_pool hash" % field do
+                    pool_hash = mock "pool hash"
+                    pool_hash.expects(:[]).with(field)
+                    @provider.stubs(:current_pool).returns(pool_hash)
+                    @provider.send(field)
+                end
+            end
+
+            describe "when setting the %s" % field do
+                it "should warn the %s values were not in sync" % field do
+                    Puppet.expects(:warning).with("NO CHANGES BEING MADE: zpool %s does not match, should be 'shouldvalue' currently is 'currentvalue'" % field)
+                    @provider.stubs(:current_pool).returns(Hash.new("currentvalue"))
+                    @provider.send((field.to_s + "=").intern, "shouldvalue")
+                end
+            end
+        end
+    end
+
+    describe "when calling create" do
+        before do
+            @resource.stubs(:[]).with(:pool).returns("mypool")
+            @provider.stubs(:zpool)
+        end
+
+
+        it "should call build_vdevs" do
+            @provider.expects(:build_vdevs).returns([])
+            @provider.create
+        end
+
+        it "should call build_named with 'spares' and 'log" do
+            @provider.expects(:build_named).with("spare").returns([])
+            @provider.expects(:build_named).with("log").returns([])
+            @provider.create
+        end
+
+        it "should call zpool with arguments from build_vdevs and build_named" do
+            @provider.expects(:zpool).with(:create, 'mypool', 'shouldvalue', 'spare', 'shouldvalue', 'log', 'shouldvalue')
+            @provider.create
+        end
+    end
+
+    describe "when calling delete" do
+        it "should call zpool with destroy and the pool name" do
+            @resource.stubs(:[]).with(:pool).returns("poolname")
+            @provider.expects(:zpool).with(:destroy, "poolname")
+            @provider.delete
+        end
+    end
+
+    describe "when calling exists?" do
+        before do
+            @current_pool = Hash.new(:absent)
+            @provider.stubs(:get_pool_data).returns([])
+            @provider.stubs(:process_zpool_data).returns(@current_pool)
+        end
+
+        it "should get the current pool" do
+            @provider.expects(:process_zpool_data).returns(@current_pool)
+            @provider.exists?
+        end
+
+        it "should return false if the current_pool is absent" do
+            #the before sets it up
+            @provider.exists?.should == false
+        end
+
+        it "should return true if the current_pool has values" do
+            @current_pool[:pool] = "mypool"
+            @provider.exists?.should == true
+        end
+    end
+
+end

data/spec/unit/rails.rb

@@ -0,0 +1,125 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'puppet/rails'
+
+describe Puppet::Rails, "when initializing any connection" do
+    confine "Cannot test without ActiveRecord" => Puppet.features.rails?
+
+    before do
+        @logger = mock 'logger'
+        @logger.stub_everything
+        Logger.stubs(:new).returns(@logger)
+
+        ActiveRecord::Base.stubs(:logger).returns(@logger)
+    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")
+        Puppet.settings.stubs(:value).with(:railslog).returns("/my/file")
+        logger = mock 'logger'
+        Logger.stubs(:new).returns(logger)
+        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" 
+
+    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",
+            :dbfile => "testlocation"
+        }
+    end
+end
+
+describe Puppet::Rails, "when initializing a mysql or postgresql connection" do
+    confine Puppet.features.rails? => "Cannot test without ActiveRecord" 
+
+    it "should provide the adapter, log_level, and host, username, password, and database arguments" do
+        Puppet.settings.stubs(:value).with(:dbadapter).returns("mysql")
+        Puppet.settings.stubs(:value).with(:rails_loglevel).returns("testlevel")
+        Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
+        Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
+        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",
+            :host => "testserver",
+            :username => "testuser",
+            :password => "testpassword",
+            :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")
+        Puppet.settings.stubs(:value).with(:dbserver).returns("testserver")
+        Puppet.settings.stubs(:value).with(:dbuser).returns("testuser")
+        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",
+            :host => "testserver",
+            :username => "testuser",
+            :password => "testpassword",
+            :database => "testname",
+            :socket => "testsocket"
+        }
+    end
+end

data/spec/unit/relationship.rb

@@ -0,0 +1,149 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-11-1.
+#  Copyright (c) 2006. All rights reserved.
+
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'puppet/relationship'
+
+describe Puppet::Relationship do
+    before do
+        @edge = Puppet::Relationship.new(:a, :b)
+    end
+
+    it "should have a :source attribute" do
+        @edge.should respond_to(:source)
+    end
+
+    it "should have a :target attribute" do
+        @edge.should respond_to(:target)
+    end
+
+    it "should have a :label attribute" do
+        @edge.should respond_to(:label)
+    end
+
+    it "should provide a :ref method that describes the edge" do
+        @edge = Puppet::Relationship.new("a", "b")
+        @edge.ref.should == "a => b"
+    end
+end
+
+describe Puppet::Relationship, " when initializing" do
+    before do
+        @edge = Puppet::Relationship.new(:a, :b, :testing => :foo)
+    end
+
+    it "should use the first argument as the source" do
+        @edge.source.should == :a
+    end
+
+    it "should use the second argument as the target" do
+        @edge.target.should == :b
+    end
+
+    it "should use the third argument as the label" do
+        @edge.label.should == {:testing => :foo}
+    end
+
+    it "should require a callback if a non-NONE event is specified" do
+        proc { Puppet::Relationship.new(:a, :b, :event => :something) }.should raise_error(ArgumentError)
+    end
+
+    it "should require the label to be a hash" do
+        proc { Puppet::Relationship.new(:a, :b, :event) }.should raise_error(ArgumentError)
+    end
+end
+
+describe Puppet::Relationship, " when interpreting the label" do
+    it "should default to an event of nil" do
+        @edge = Puppet::Relationship.new(:a, :b)
+        @edge.event.should be_nil
+    end
+
+    it "should expose a provided event via the :event method" do
+        @edge = Puppet::Relationship.new(:a, :b, :event => :something, :callback => :whatever)
+        @edge.event.should == :something
+    end
+
+    it "should default to a nil callback" do
+        @edge = Puppet::Relationship.new(:a, :b)
+        @edge.callback.should be_nil
+    end
+
+    it "should expose a provided callback via the :callback method" do
+        @edge = Puppet::Relationship.new(:a, :b, :callback => :testing)
+        @edge.callback.should == :testing
+    end
+end
+
+describe Puppet::Relationship, " when matching edges with no specified event" do
+    before do
+        @edge = Puppet::Relationship.new(:a, :b)
+    end
+
+    it "should not match :NONE" do
+        @edge.should_not be_match(:NONE)
+    end
+
+    it "should not match :ALL_EVENTS" do
+        @edge.should_not be_match(:NONE)
+    end
+
+    it "should not match any other events" do
+        @edge.should_not be_match(:whatever)
+    end
+end
+
+describe Puppet::Relationship, " when matching edges with :NONE as the event" do
+    before do
+        @edge = Puppet::Relationship.new(:a, :b, :event => :NONE)
+    end
+    it "should not match :NONE" do
+        @edge.should_not be_match(:NONE)
+    end
+
+    it "should not match :ALL_EVENTS" do
+        @edge.should_not be_match(:ALL_EVENTS)
+    end
+
+    it "should not match other events" do
+        @edge.should_not be_match(:yayness)
+    end
+end
+
+describe Puppet::Relationship, " when matching edges with :ALL as the event" do
+    before do
+        @edge = Puppet::Relationship.new(:a, :b, :event => :ALL_EVENTS, :callback => :whatever)
+    end
+
+    it "should not match :NONE" do
+        @edge.should_not be_match(:NONE)
+    end
+
+    it "should match :ALL_EVENTS" do
+        @edge.should be_match(:ALLEVENTS)
+    end
+
+    it "should match all other events" do
+        @edge.should be_match(:foo)
+    end
+end
+
+describe Puppet::Relationship, " when matching edges with a non-standard event" do
+    before do
+        @edge = Puppet::Relationship.new(:a, :b, :event => :random, :callback => :whatever)
+    end
+
+    it "should not match :NONE" do
+        @edge.should_not be_match(:NONE)
+    end
+
+    it "should not match :ALL_EVENTS" do
+        @edge.should_not be_match(:ALL_EVENTS)
+    end
+
+    it "should match events with the same name" do
+        @edge.should be_match(:random)
+    end
+end