puppet 0.25.5 → 2.6.0

data/spec/unit/application/ralsh.rb

@@ -1,254 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require 'puppet/application/ralsh'
-
-describe "ralsh" do
-    before :each do
-        @ralsh = Puppet::Application[:ralsh]
-        Puppet::Util::Log.stubs(:newdestination)
-        Puppet::Util::Log.stubs(:level=)
-    end
-
-    it "should ask Puppet::Application to not parse Puppet configuration file" do
-        @ralsh.should_parse_config?.should be_false
-    end
-
-    it "should declare a main command" do
-        @ralsh.should respond_to(:main)
-    end
-
-    it "should declare a host option" do
-        @ralsh.should respond_to(:handle_host)
-    end
-
-    it "should declare a types option" do
-        @ralsh.should respond_to(:handle_types)
-    end
-
-    it "should declare a param option" do
-        @ralsh.should respond_to(:handle_param)
-    end
-
-    it "should declare a preinit block" do
-        @ralsh.should respond_to(:run_preinit)
-    end
-
-    describe "in preinit" do
-        it "should set hosts to nil" do
-            @ralsh.run_preinit
-
-            @ralsh.host.should be_nil
-        end
-
-        it "should init extra_params to empty array" do
-            @ralsh.run_preinit
-
-            @ralsh.extra_params.should == []
-        end
-
-        it "should load Facter facts" do
-          Facter.expects(:loadfacts).once
-          @ralsh.run_preinit
-        end
-    end
-
-    describe "when handling options" do
-
-        [:debug, :verbose, :edit].each do |option|
-            it "should declare handle_#{option} method" do
-                @ralsh.should respond_to("handle_#{option}".to_sym)
-            end
-
-            it "should store argument value when calling handle_#{option}" do
-                @ralsh.options.expects(:[]=).with(option, 'arg')
-                @ralsh.send("handle_#{option}".to_sym, 'arg')
-            end
-        end
-
-        it "should set options[:host] to given host" do
-            @ralsh.handle_host(:whatever)
-
-            @ralsh.host.should == :whatever
-        end
-
-        it "should load an display all types with types option" do
-            type1 = stub_everything 'type1', :name => :type1
-            type2 = stub_everything 'type2', :name => :type2
-            Puppet::Type.stubs(:loadall)
-            Puppet::Type.stubs(:eachtype).multiple_yields(type1,type2)
-            @ralsh.stubs(:exit)
-
-            @ralsh.expects(:puts).with(['type1','type2'])
-            @ralsh.handle_types(nil)
-        end
-
-        it "should add param to extra_params list" do
-            @ralsh.extra_params = [ :param1 ]
-            @ralsh.handle_param("whatever")
-
-            @ralsh.extra_params.should == [ :param1, :whatever ]
-        end
-    end
-
-    describe "during setup" do
-        before :each do
-            Puppet::Log.stubs(:newdestination)
-            Puppet::Log.stubs(:level=)
-            Puppet.stubs(:parse_config)
-        end
-
-
-        it "should set console as the log destination" do
-            Puppet::Log.expects(:newdestination).with(:console)
-
-            @ralsh.run_setup
-        end
-
-        it "should set log level to debug if --debug was passed" do
-            @ralsh.options.stubs(:[]).with(:debug).returns(true)
-
-            Puppet::Log.expects(:level=).with(:debug)
-
-            @ralsh.run_setup
-        end
-
-        it "should set log level to info if --verbose was passed" do
-            @ralsh.options.stubs(:[]).with(:debug).returns(false)
-            @ralsh.options.stubs(:[]).with(:verbose).returns(true)
-
-            Puppet::Log.expects(:level=).with(:info)
-
-            @ralsh.run_setup
-        end
-
-        it "should Parse puppet config" do
-            Puppet.expects(:parse_config)
-
-            @ralsh.run_setup
-        end
-    end
-
-    describe "when running" do
-
-        def set_args(args)
-            (ARGV.clear << args).flatten!
-        end
-
-        def push_args(*args)
-            @args_stack ||= []
-            @args_stack << ARGV.dup
-            set_args(args)
-        end
-
-        def pop_args
-            set_args(@args_stack.pop)
-        end
-
-        before :each do
-            @type = stub_everything 'type', :properties => []
-            push_args('type')
-            Puppet::Type.stubs(:type).returns(@type)
-        end
-
-        after :each do
-            pop_args
-        end
-
-        it "should raise an error if no type is given" do
-            push_args
-            lambda { @ralsh.main }.should raise_error
-            pop_args
-        end
-
-        it "should raise an error when editing a remote host" do
-            @ralsh.options.stubs(:[]).with(:edit).returns(true)
-            @ralsh.host = 'host'
-
-            lambda { @ralsh.main }.should raise_error
-        end
-
-        it "should raise an error if the type is not found" do
-            Puppet::Type.stubs(:type).returns(nil)
-
-            lambda { @ralsh.main }.should raise_error
-        end
-
-        describe "with a host" do
-            before :each do
-                @ralsh.stubs(:puts)
-                @ralsh.host = 'host'
-                @client = stub_everything 'client'
-                @client.stubs(:read_cert).returns(true)
-                @client.stubs(:instances).returns([])
-                Puppet::Network::Client.resource.stubs(:new).returns(@client)
-            end
-
-            it "should connect to it" do
-                Puppet::Network::Client.resource.expects(:new).with { |h| h[:Server] == 'host' }.returns(@client)
-                @ralsh.main
-            end
-
-            it "should raise an error if there are no certs" do
-                @client.stubs(:read_cert).returns(nil)
-
-                lambda { @ralsh.main }.should raise_error
-            end
-
-            it "should retrieve all the instances if there is no name" do
-                @client.expects(:instances).returns([])
-
-                @ralsh.main
-            end
-
-            it "should describe the given resource" do
-                push_args('type','name')
-                @client.expects(:describe).returns(stub_everything)
-                @ralsh.main
-                pop_args
-            end
-        end
-
-        describe "without a host" do
-            before :each do
-                @ralsh.stubs(:puts)
-                @ralsh.host = nil
-            end
-
-            it "should retrieve all the instances if there is no name" do
-                @type.expects(:instances).returns([])
-
-                @ralsh.main
-            end
-
-            describe 'but with a given name' do
-                before :each do
-                    push_args('type','name')
-                    @type.stubs(:new).returns(:bob)
-                end
-
-                after :each do
-                    pop_args
-                end
-
-                it "should retrieve a specific instance if it exists" do
-                    pending
-                end
-
-
-                it "should create a stub instance if it doesn't exist" do
-                    pending
-                end
-
-                it "should add given parameters to the object" do
-                    push_args('type','name','param=temp')
-                    pending
-                    @object.expects(:[]=).with('param','temp')
-                    @ralsh.main
-                    pop_args
-                end
-            end
-        end
-    end
-end

data/spec/unit/configurer.rb

@@ -1,339 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Luke Kanies on 2007-11-12.
-#  Copyright (c) 2007. All rights reserved.
-
-require File.dirname(__FILE__) + '/../spec_helper'
-require 'puppet/configurer'
-
-describe Puppet::Configurer do
-    before do
-        Puppet.settings.stubs(:use).returns(true)
-        @agent = Puppet::Configurer.new
-    end
-
-    it "should include the Plugin Handler module" do
-        Puppet::Configurer.ancestors.should be_include(Puppet::Configurer::PluginHandler)
-    end
-
-    it "should include the Fact Handler module" do
-        Puppet::Configurer.ancestors.should be_include(Puppet::Configurer::FactHandler)
-    end
-
-    it "should use the puppetdlockfile as its lockfile path" do
-        Puppet.settings.expects(:value).with(:puppetdlockfile).returns("/my/lock")
-        Puppet::Configurer.lockfile_path.should == "/my/lock"
-    end
-
-    describe "when executing a pre-run hook" do
-        it "should do nothing if the hook is set to an empty string" do
-            Puppet.settings[:prerun_command] = ""
-            Puppet::Util.expects(:exec).never
-
-            @agent.execute_prerun_command
-        end
-
-        it "should execute any pre-run command provided via the 'prerun_command' setting" do
-            Puppet.settings[:prerun_command] = "/my/command"
-            Puppet::Util.expects(:execute).with { |args| args[0] == "/my/command" }
-
-            @agent.execute_prerun_command
-        end
-
-        it "should fail if the command fails" do
-            Puppet.settings[:prerun_command] = "/my/command"
-            Puppet::Util.expects(:execute).raises Puppet::ExecutionFailure
-
-            lambda { @agent.execute_prerun_command }.should raise_error(Puppet::Configurer::CommandHookError)
-        end
-    end
-
-    describe "when executing a post-run hook" do
-        it "should do nothing if the hook is set to an empty string" do
-            Puppet.settings[:postrun_command] = ""
-            Puppet::Util.expects(:exec).never
-
-            @agent.execute_postrun_command
-        end
-
-        it "should execute any post-run command provided via the 'postrun_command' setting" do
-            Puppet.settings[:postrun_command] = "/my/command"
-            Puppet::Util.expects(:execute).with { |args| args[0] == "/my/command" }
-
-            @agent.execute_postrun_command
-        end
-
-        it "should fail if the command fails" do
-            Puppet.settings[:postrun_command] = "/my/command"
-            Puppet::Util.expects(:execute).raises Puppet::ExecutionFailure
-
-            lambda { @agent.execute_postrun_command }.should raise_error(Puppet::Configurer::CommandHookError)
-        end
-    end
-end
-
-describe Puppet::Configurer, "when executing a catalog run" do
-    before do
-        Puppet.settings.stubs(:use).returns(true)
-        @agent = Puppet::Configurer.new
-        @agent.stubs(:facts_for_uploading).returns({})
-        @agent.stubs(:retrieve_catalog).returns Puppet::Resource::Catalog.new
-    end
-
-    it "should prepare for the run" do
-        @agent.expects(:prepare)
-
-        @agent.run
-    end
-
-    it "should retrieve the catalog" do
-        @agent.expects(:retrieve_catalog)
-
-        @agent.run
-    end
-
-    it "should log a failure and do nothing if no catalog can be retrieved" do
-        @agent.expects(:retrieve_catalog).returns nil
-
-        Puppet.expects(:err)
-
-        @agent.run
-    end
-
-    it "should apply the catalog with all options to :run" do
-        catalog = stub 'catalog', :retrieval_duration= => nil
-        @agent.expects(:retrieve_catalog).returns catalog
-
-        catalog.expects(:apply).with(:one => true)
-        @agent.run :one => true
-    end
-
-    it "should accept a catalog and use it instead of retrieving a different one" do
-        catalog = stub 'catalog', :retrieval_duration= => nil
-        @agent.expects(:retrieve_catalog).never
-
-        catalog.expects(:apply).with(:one => true)
-        @agent.run :one => true, :catalog => catalog
-    end
-
-    it "should benchmark how long it takes to apply the catalog" do
-        @agent.expects(:benchmark).with(:notice, "Finished catalog run")
-
-        catalog = stub 'catalog', :retrieval_duration= => nil
-        @agent.expects(:retrieve_catalog).returns catalog
-
-        catalog.expects(:apply).never # because we're not yielding
-        @agent.run
-    end
-
-    it "should execute post-run hooks after the run" do
-        @agent.expects(:execute_postrun_command)
-
-        @agent.run
-    end
-end
-
-describe Puppet::Configurer, "when retrieving a catalog" do
-    before do
-        Puppet.settings.stubs(:use).returns(true)
-        @agent = Puppet::Configurer.new
-        @agent.stubs(:facts_for_uploading).returns({})
-
-        @catalog = Puppet::Resource::Catalog.new
-
-        # this is the default when using a Configurer instance
-        Puppet::Resource::Catalog.indirection.stubs(:terminus_class).returns :rest
-
-        @agent.stubs(:convert_catalog).returns @catalog
-    end
-
-    describe "and configured to only retrieve a catalog from the cache" do
-        before do
-            Puppet.settings[:use_cached_catalog] = true
-        end
-
-        it "should first look in the cache for a catalog" do
-            Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
-            Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.never
-
-            @agent.retrieve_catalog.should == @catalog
-        end
-
-        it "should compile a new catalog if none is found in the cache" do
-            Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
-            Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
-
-            @agent.retrieve_catalog.should == @catalog
-        end
-    end
-
-    describe "when not using a REST terminus for catalogs" do
-        it "should not pass any facts when retrieving the catalog" do
-            @agent.expects(:facts_for_uploading).never
-            Puppet::Resource::Catalog.expects(:find).with { |name, options|
-                options[:facts].nil?
-            }.returns @catalog
-
-            @agent.retrieve_catalog
-        end
-    end
-
-    describe "when using a REST terminus for catalogs" do
-        it "should pass the prepared facts and the facts format as arguments when retrieving the catalog" do
-            @agent.expects(:facts_for_uploading).returns(:facts => "myfacts", :facts_format => :foo)
-            Puppet::Resource::Catalog.expects(:find).with { |name, options|
-                options[:facts] == "myfacts" and options[:facts_format] == :foo
-            }.returns @catalog
-
-            @agent.retrieve_catalog
-        end
-    end
-
-    it "should use the Catalog class to get its catalog" do
-        Puppet::Resource::Catalog.expects(:find).returns @catalog
-
-        @agent.retrieve_catalog
-    end
-
-    it "should use its certname to retrieve the catalog" do
-        Facter.stubs(:value).returns "eh"
-        Puppet.settings[:certname] = "myhost.domain.com"
-        Puppet::Resource::Catalog.expects(:find).with { |name, options| name == "myhost.domain.com" }.returns @catalog
-
-        @agent.retrieve_catalog
-    end
-
-    it "should default to returning a catalog retrieved directly from the server, skipping the cache" do
-        Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
-
-        @agent.retrieve_catalog.should == @catalog
-    end
-
-    it "should log and return the cached catalog when no catalog can be retrieved from the server" do
-        Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
-        Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
-
-        Puppet.expects(:notice)
-
-        @agent.retrieve_catalog.should == @catalog
-    end
-
-    it "should not look in the cache for a catalog if one is returned from the server" do
-        Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns @catalog
-        Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_terminus] == true }.never
-
-        @agent.retrieve_catalog.should == @catalog
-    end
-
-    it "should return the cached catalog when retrieving the remote catalog throws an exception" do
-        Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.raises "eh"
-        Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns @catalog
-
-        @agent.retrieve_catalog.should == @catalog
-    end
-
-    it "should log and return nil if no catalog can be retrieved from the server and :usecacheonfailure is disabled" do
-        Puppet.stubs(:[])
-        Puppet.expects(:[]).with(:usecacheonfailure).returns false
-        Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
-
-        Puppet.expects(:warning)
-
-        @agent.retrieve_catalog.should be_nil
-    end
-
-    it "should return nil if no cached catalog is available and no catalog can be retrieved from the server" do
-        Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_cache] == true }.returns nil
-        Puppet::Resource::Catalog.expects(:find).with { |name, options| options[:ignore_terminus] == true }.returns nil
-
-        @agent.retrieve_catalog.should be_nil
-    end
-
-    it "should convert the catalog before returning" do
-        Puppet::Resource::Catalog.stubs(:find).returns @catalog
-
-        @agent.expects(:convert_catalog).with { |cat, dur| cat == @catalog }.returns "converted catalog"
-        @agent.retrieve_catalog.should == "converted catalog"
-    end
-
-    it "should return nil if there is an error while retrieving the catalog" do
-        Puppet::Resource::Catalog.expects(:find).raises "eh"
-
-        @agent.retrieve_catalog.should be_nil
-    end
-end
-
-describe Puppet::Configurer, "when converting the catalog" do
-    before do
-        Puppet.settings.stubs(:use).returns(true)
-        @agent = Puppet::Configurer.new
-
-        @catalog = Puppet::Resource::Catalog.new
-        @oldcatalog = stub 'old_catalog', :to_ral => @catalog
-    end
-
-    it "should convert the catalog to a RAL-formed catalog" do
-        @oldcatalog.expects(:to_ral).returns @catalog
-
-        @agent.convert_catalog(@oldcatalog, 10).should equal(@catalog)
-    end
-
-    it "should finalize the catalog" do
-        @catalog.expects(:finalize)
-
-        @agent.convert_catalog(@oldcatalog, 10)
-    end
-
-    it "should record the passed retrieval time with the RAL catalog" do
-        @catalog.expects(:retrieval_duration=).with 10
-
-        @agent.convert_catalog(@oldcatalog, 10)
-    end
-
-    it "should write the RAL catalog's class file" do
-        @catalog.expects(:write_class_file)
-
-        @agent.convert_catalog(@oldcatalog, 10)
-    end
-
-    it "should mark the RAL catalog as a host catalog" do
-        @catalog.expects(:host_config=).with true
-
-        @agent.convert_catalog(@oldcatalog, 10)
-    end
-end
-
-describe Puppet::Configurer, "when preparing for a run" do
-    before do
-        Puppet.settings.stubs(:use).returns(true)
-        @agent = Puppet::Configurer.new
-        @agent.stubs(:dostorage)
-        @agent.stubs(:download_fact_plugins)
-        @agent.stubs(:download_plugins)
-        @agent.stubs(:execute_prerun_command)
-        @facts = {"one" => "two", "three" => "four"}
-    end
-
-    it "should initialize the metadata store" do
-        @agent.class.stubs(:facts).returns(@facts)
-        @agent.expects(:dostorage)
-        @agent.prepare
-    end
-
-    it "should download fact plugins" do
-        @agent.expects(:download_fact_plugins)
-
-        @agent.prepare
-    end
-
-    it "should download plugins" do
-        @agent.expects(:download_plugins)
-
-        @agent.prepare
-    end
-
-    it "should perform the pre-run commands" do
-        @agent.expects(:execute_prerun_command)
-        @agent.prepare
-    end
-end