puppet 0.25.5 → 2.6.0

data/spec/unit/application/filebucket.rb

@@ -1,220 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require 'puppet/application/filebucket'
-
-describe "Filebucket" do
-    before :each do
-        @filebucket = Puppet::Application[:filebucket]
-    end
-
-    it "should ask Puppet::Application to not parse Puppet configuration file" do
-        @filebucket.should_parse_config?.should be_false
-    end
-
-    it "should declare a get command" do
-        @filebucket.should respond_to(:get)
-    end
-
-    it "should declare a backup command" do
-        @filebucket.should respond_to(:backup)
-    end
-
-    it "should declare a restore command" do
-        @filebucket.should respond_to(:restore)
-    end
-
-    [:bucket, :debug, :local, :remote, :verbose].each do |option|
-        it "should declare handle_#{option} method" do
-            @filebucket.should respond_to("handle_#{option}".to_sym)
-        end
-
-        it "should store argument value when calling handle_#{option}" do
-            @filebucket.options.expects(:[]=).with("#{option}".to_sym, 'arg')
-            @filebucket.send("handle_#{option}".to_sym, 'arg')
-        end
-    end
-
-    describe "during setup" do
-
-        before :each do
-            Puppet::Log.stubs(:newdestination)
-            Puppet.stubs(:settraps)
-            Puppet::Log.stubs(:level=)
-            Puppet.stubs(:parse_config)
-            Puppet::Network::Client.dipper.stubs(:new)
-            @filebucket.options.stubs(:[]).with(any_parameters)
-        end
-
-
-        it "should set console as the log destination" do
-            Puppet::Log.expects(:newdestination).with(:console)
-
-            @filebucket.run_setup
-        end
-
-        it "should trap INT" do
-            @filebucket.expects(:trap).with(:INT)
-
-            @filebucket.run_setup
-        end
-
-        it "should set log level to debug if --debug was passed" do
-            @filebucket.options.stubs(:[]).with(:debug).returns(true)
-
-            Puppet::Log.expects(:level=).with(:debug)
-
-            @filebucket.run_setup
-        end
-
-        it "should set log level to info if --verbose was passed" do
-            @filebucket.options.stubs(:[]).with(:verbose).returns(true)
-
-            Puppet::Log.expects(:level=).with(:info)
-
-            @filebucket.run_setup
-        end
-
-        it "should Parse puppet config" do
-            Puppet.expects(:parse_config)
-
-            @filebucket.run_setup
-        end
-
-        it "should print puppet config if asked to in Puppet config" do
-            @filebucket.stubs(:exit)
-            Puppet.settings.stubs(:print_configs?).returns(true)
-
-            Puppet.settings.expects(:print_configs)
-
-            @filebucket.run_setup
-        end
-
-        it "should exit after printing puppet config if asked to in Puppet config" do
-            Puppet.settings.stubs(:print_configs?).returns(true)
-
-            lambda { @filebucket.run_setup }.should raise_error(SystemExit)
-        end
-
-        describe "with local bucket" do
-
-            before :each do
-                @filebucket.options.stubs(:[]).with(:local).returns(true)
-            end
-
-            it "should create a client with the default bucket if none passed" do
-                Puppet.stubs(:[]).with(:bucketdir).returns("path")
-
-                Puppet::Network::Client::Dipper.expects(:new).with { |h| h[:Path] == "path" }
-
-                @filebucket.run_setup
-            end
-
-            it "should create a local Client dipper with the given bucket" do
-                @filebucket.options.stubs(:[]).with(:bucket).returns("path")
-
-                Puppet::Network::Client::Dipper.expects(:new).with { |h| h[:Path] == "path" }
-
-                @filebucket.run_setup
-            end
-
-        end
-
-        describe "with remote bucket" do
-
-            it "should create a remote Client to the configured server" do
-                Puppet.stubs(:[]).with(:server).returns("puppet.puppetlabs.com")
-
-                Puppet::Network::Client::Dipper.expects(:new).with { |h| h[:Server] == "puppet.puppetlabs.com" }
-
-                @filebucket.run_setup
-            end
-
-        end
-
-    end
-
-    describe "when running" do
-
-        before :each do
-            Puppet::Log.stubs(:newdestination)
-            Puppet.stubs(:settraps)
-            Puppet::Log.stubs(:level=)
-            Puppet.stubs(:parse_config)
-            Puppet::Network::Client.dipper.stubs(:new)
-            @filebucket.options.stubs(:[]).with(any_parameters)
-
-            @client = stub 'client'
-            Puppet::Network::Client::Dipper.stubs(:new).returns(@client)
-
-            @filebucket.run_setup
-        end
-
-        it "should use the first non-option parameter as the dispatch" do
-            ARGV.stubs(:shift).returns(:get)
-
-            @filebucket.get_command.should == :get
-        end
-
-        describe "the command get" do
-
-            before :each do
-                @filebucket.stubs(:print)
-            end
-
-            it "should call the client getfile method" do
-                @client.expects(:getfile)
-
-                @filebucket.get
-            end
-
-            it "should call the client getfile method with the given md5" do
-                md5="DEADBEEF"
-                ARGV.stubs(:shift).returns(md5)
-
-                @client.expects(:getfile).with(md5)
-
-                @filebucket.get
-            end
-
-            it "should print the file content" do
-                @client.stubs(:getfile).returns("content")
-
-                @filebucket.expects(:print).returns("content")
-
-                @filebucket.get
-            end
-
-        end
-
-        describe "the command backup" do
-            it "should call the client backup method for each given parameter" do
-                @filebucket.stubs(:puts)
-                FileTest.stubs(:exists?).returns(true)
-                FileTest.stubs(:readable?).returns(true)
-                ARGV.stubs(:each).multiple_yields("file1","file2")
-
-                @client.expects(:backup).with("file1")
-                @client.expects(:backup).with("file2")
-
-                @filebucket.backup
-            end
-        end
-
-        describe "the command restore" do
-            it "should call the client getfile method with the given md5" do
-                md5="DEADBEEF"
-                file="testfile"
-                ARGV.stubs(:shift).returns(file,md5)
-
-                @client.expects(:restore).with(file,md5)
-
-                @filebucket.restore
-            end
-        end
-
-    end
-
-
-end

data/spec/unit/application/pi.rb

@@ -1,84 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require 'puppet/application/pi'
-
-describe "pi" do
-    before :each do
-        @pi = Puppet::Application[:pi]
-    end
-
-    it "should ask Puppet::Application to not parse Puppet configuration file" do
-        @pi.should_parse_config?.should be_false
-    end
-
-    it "should declare a main command" do
-        @pi.should respond_to(:main)
-    end
-
-    it "should declare a preinit block" do
-        @pi.should respond_to(:run_preinit)
-    end
-
-    [:providers,:list,:meta].each do |option|
-        it "should declare handle_#{option} method" do
-            @pi.should respond_to("handle_#{option}".to_sym)
-        end
-
-        it "should store argument value when calling handle_#{option}" do
-            @pi.options.expects(:[]=).with("#{option}".to_sym, 'arg')
-            @pi.send("handle_#{option}".to_sym, 'arg')
-        end
-    end
-
-
-    describe "in preinit" do
-        it "should set options[:parameteers] to true" do
-            @pi.run_preinit
-
-            @pi.options[:parameters].should be_true
-        end
-    end
-
-    describe "when handling parameters" do
-        it "should set options[:parameters] to false" do
-            @pi.handle_short(nil)
-
-            @pi.options[:parameters].should be_false
-        end
-    end
-
-    describe "during setup" do
-        it "should collect ARGV in options[:types]" do
-            ARGV.stubs(:dup).returns(['1','2'])
-            @pi.run_setup
-
-            @pi.options[:types].should == ['1','2']
-        end
-    end
-
-    describe "when running" do
-
-        before :each do
-            @typedoc = stub 'type_doc'
-            TypeDoc.stubs(:new).returns(@typedoc)
-        end
-
-        it "should call list_types if options list is set" do
-            @pi.options[:list] = true
-
-            @typedoc.expects(:list_types)
-
-            @pi.run_command
-        end
-
-        it "should call format_type for each given types" do
-            @pi.options[:list] = false
-            @pi.options[:types] = ['type']
-
-            @typedoc.expects(:format_type).with('type', @pi.options)
-            @pi.run_command
-        end
-    end
-end

data/spec/unit/application/puppet.rb

@@ -1,399 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require 'puppet/application/puppet'
-
-describe "Puppet" do
-    before :each do
-        @puppet = Puppet::Application[:puppet]
-        Puppet::Util::Log.stubs(:newdestination)
-        Puppet::Util::Log.stubs(:level=)
-    end
-
-    [:debug,:loadclasses,:verbose,:use_nodes,:detailed_exitcodes].each do |option|
-        it "should declare handle_#{option} method" do
-            @puppet.should respond_to("handle_#{option}".to_sym)
-        end
-
-        it "should store argument value when calling handle_#{option}" do
-            @puppet.options.expects(:[]=).with(option, 'arg')
-            @puppet.send("handle_#{option}".to_sym, 'arg')
-        end
-    end
-
-    it "should set the code to the provided code when :execute is used" do
-        @puppet.options.expects(:[]=).with(:code, 'arg')
-        @puppet.send("handle_execute".to_sym, 'arg')
-    end
-
-    it "should ask Puppet::Application to parse Puppet configuration file" do
-        @puppet.should_parse_config?.should be_true
-    end
-
-    describe "when applying options" do
-
-        it "should set the log destination with --logdest" do
-            Puppet::Log.expects(:newdestination).with("console")
-
-            @puppet.handle_logdest("console")
-        end
-
-        it "should put the logset options to true" do
-            @puppet.options.expects(:[]=).with(:logset,true)
-
-            @puppet.handle_logdest("console")
-        end
-    end
-
-    describe "during setup" do
-
-        before :each do
-            Puppet::Log.stubs(:newdestination)
-            Puppet.stubs(:trap)
-            Puppet::Log.stubs(:level=)
-            Puppet.stubs(:parse_config)
-            Puppet::Network::Client.dipper.stubs(:new)
-            STDIN.stubs(:read)
-
-            @puppet.options.stubs(:[]).with(any_parameters)
-        end
-
-        it "should set show_diff on --noop" do
-            Puppet.stubs(:[]=)
-            Puppet.stubs(:[]).with(:config)
-            Puppet.stubs(:[]).with(:noop).returns(true)
-
-            Puppet.expects(:[]=).with(:show_diff, true)
-
-            @puppet.run_setup
-        end
-
-        it "should set console as the log destination if logdest option wasn't provided" do
-            Puppet::Log.expects(:newdestination).with(:console)
-
-            @puppet.run_setup
-        end
-
-        it "should set INT trap" do
-            @puppet.expects(:trap).with(:INT)
-
-            @puppet.run_setup
-        end
-
-        it "should set log level to debug if --debug was passed" do
-            @puppet.options.stubs(:[]).with(:debug).returns(true)
-
-            Puppet::Log.expects(:level=).with(:debug)
-
-            @puppet.run_setup
-        end
-
-        it "should set log level to info if --verbose was passed" do
-            @puppet.options.stubs(:[]).with(:verbose).returns(true)
-
-            Puppet::Log.expects(:level=).with(:info)
-
-            @puppet.run_setup
-        end
-
-        it "should print puppet config if asked to in Puppet config" do
-            @puppet.stubs(:exit)
-            Puppet.settings.stubs(:print_configs?).returns(true)
-
-            Puppet.settings.expects(:print_configs)
-
-            @puppet.run_setup
-        end
-
-        it "should exit after printing puppet config if asked to in Puppet config" do
-            Puppet.settings.stubs(:print_configs?).returns(true)
-
-            lambda { @puppet.run_setup }.should raise_error(SystemExit)
-        end
-
-    end
-
-    describe "when executing" do
-
-        it "should dispatch to parseonly if parseonly is set" do
-            @puppet.stubs(:options).returns({})
-            Puppet.stubs(:[]).with(:parseonly).returns(true)
-
-            @puppet.get_command.should == :parseonly
-        end
-
-        it "should dispatch to 'apply' if it was called with 'apply'" do
-            @puppet.options[:catalog] = "foo"
-
-            @puppet.get_command.should == :apply
-        end
-
-        it "should dispatch to main if parseonly is not set" do
-            @puppet.stubs(:options).returns({})
-            Puppet.stubs(:[]).with(:parseonly).returns(false)
-
-            @puppet.get_command.should == :main
-        end
-
-        describe "the parseonly command" do
-            before :each do
-                Puppet.stubs(:[]).with(:environment)
-                Puppet.stubs(:[]).with(:manifest).returns("site.pp")
-                @interpreter = stub_everything
-                Puppet.stubs(:err)
-                @puppet.stubs(:exit)
-                @puppet.options.stubs(:[]).with(:code).returns "some code"
-                Puppet::Parser::Interpreter.stubs(:new).returns(@interpreter)
-            end
-
-            it "should delegate to the Puppet Parser" do
-
-                @interpreter.expects(:parser)
-
-                @puppet.parseonly
-            end
-
-            it "should exit with exit code 0 if no error" do
-                @puppet.expects(:exit).with(0)
-
-                @puppet.parseonly
-            end
-
-            it "should exit with exit code 1 if error" do
-                @interpreter.stubs(:parser).raises(Puppet::ParseError)
-
-                @puppet.expects(:exit).with(1)
-
-                @puppet.parseonly
-            end
-
-        end
-
-        describe "the main command" do
-            before :each do
-                Puppet.stubs(:[])
-                Puppet.settings.stubs(:use)
-                Puppet.stubs(:[]).with(:prerun_command).returns ""
-                Puppet.stubs(:[]).with(:postrun_command).returns ""
-                Puppet.stubs(:[]).with(:trace).returns(true)
-
-                @puppet.options.stubs(:[])
-
-                @facts = stub_everything 'facts'
-                Puppet::Node::Facts.stubs(:find).returns(@facts)
-
-                @node = stub_everything 'node'
-                Puppet::Node.stubs(:find).returns(@node)
-
-                @catalog = stub_everything 'catalog'
-                @catalog.stubs(:to_ral).returns(@catalog)
-                Puppet::Resource::Catalog.stubs(:find).returns(@catalog)
-
-                STDIN.stubs(:read)
-
-                @transaction = stub_everything 'transaction'
-                @catalog.stubs(:apply).returns(@transaction)
-
-                @puppet.stubs(:exit)
-            end
-
-            it "should set the code to run from --code" do
-                @puppet.options.stubs(:[]).with(:code).returns("code to run")
-                Puppet.expects(:[]=).with(:code,"code to run")
-
-                @puppet.main
-            end
-
-            it "should set the code to run from STDIN if no arguments" do
-                ARGV.stubs(:length).returns(0)
-                STDIN.stubs(:read).returns("code to run")
-
-                Puppet.expects(:[]=).with(:code,"code to run")
-
-                @puppet.main
-            end
-
-            it "should set the manifest if some files are passed on command line" do
-                ARGV.stubs(:length).returns(1)
-                ARGV.stubs(:shift).returns("site.pp")
-
-                Puppet.expects(:[]=).with(:manifest,"site.pp")
-
-                @puppet.main
-            end
-
-            it "should collect the node facts" do
-                Puppet::Node::Facts.expects(:find).returns(@facts)
-
-                @puppet.main
-            end
-
-            it "should find the node" do
-                Puppet::Node.expects(:find).returns(@node)
-
-                @puppet.main
-            end
-
-            it "should raise an error if we can't find the node" do
-                Puppet::Node.expects(:find).returns(nil)
-
-                lambda { @puppet.main }.should raise_error
-            end
-
-            it "should merge in our node the loaded facts" do
-                @facts.stubs(:values).returns("values")
-
-                @node.expects(:merge).with("values")
-
-                @puppet.main
-            end
-
-            it "should load custom classes if loadclasses" do
-                @puppet.options.stubs(:[]).with(:loadclasses).returns(true)
-                Puppet.stubs(:[]).with(:classfile).returns("/etc/puppet/classes.txt")
-                FileTest.stubs(:exists?).with("/etc/puppet/classes.txt").returns(true)
-                FileTest.stubs(:readable?).with("/etc/puppet/classes.txt").returns(true)
-                File.stubs(:read).with("/etc/puppet/classes.txt").returns("class")
-
-                @node.expects(:classes=)
-
-                @puppet.main
-            end
-
-            it "should compile the catalog" do
-                Puppet::Resource::Catalog.expects(:find).returns(@catalog)
-
-                @puppet.main
-            end
-
-            it "should transform the catalog to ral" do
-
-                @catalog.expects(:to_ral).returns(@catalog)
-
-                @puppet.main
-            end
-
-            it "should finalize the catalog" do
-                @catalog.expects(:finalize)
-
-                @puppet.main
-            end
-
-            it "should call the prerun and postrun commands on a Configurer instance" do
-                configurer = stub 'configurer'
-
-                Puppet::Configurer.expects(:new).returns configurer
-                configurer.expects(:execute_prerun_command)
-                configurer.expects(:execute_postrun_command)
-
-                @puppet.main
-            end
-
-            it "should apply the catalog" do
-                @catalog.expects(:apply)
-
-                @puppet.main
-            end
-
-            it "should generate a report if not noop" do
-                Puppet.stubs(:[]).with(:noop).returns(false)
-                @puppet.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
-                metrics = stub 'metrics', :[] => { :total => 10, :failed => 0}
-                report = stub 'report', :metrics => metrics
-                @transaction.stubs(:report).returns(report)
-
-                @transaction.expects(:generate_report)
-
-                @puppet.main
-            end
-
-            describe "with detailed_exitcodes" do
-                before :each do
-                    Puppet.stubs(:[]).with(:noop).returns(false)
-                    @puppet.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
-                end
-
-                it "should exit with exit code of 2 if changes" do
-                    report = stub 'report', :metrics => { "changes" => {:total => 1}, "resources" => {:failed => 0} }
-                    @transaction.stubs(:generate_report).returns(report)
-                    @transaction.stubs(:report).returns(report)
-                    @puppet.expects(:exit).with(2)
-
-                    @puppet.main
-                end
-
-                it "should exit with exit code of 4 if failures" do
-                    report = stub 'report', :metrics => { "changes" => {:total => 0}, "resources" => {:failed => 1} }
-                    @transaction.stubs(:generate_report).returns(report)
-                    @transaction.stubs(:report).returns(report)
-                    @puppet.expects(:exit).with(4)
-
-                    @puppet.main
-                end
-
-                it "should exit with exit code of 6 if changes and failures" do
-                    report = stub 'report', :metrics => { "changes" => {:total => 1}, "resources" => {:failed => 1} }
-                    @transaction.stubs(:generate_report).returns(report)
-                    @transaction.stubs(:report).returns(report)
-                    @puppet.expects(:exit).with(6)
-
-                    @puppet.main
-                end
-            end
-
-        end
-
-        describe "the 'apply' command" do
-            it "should read the catalog in from disk if a file name is provided" do
-                @puppet.options[:catalog] = "/my/catalog.pson"
-                File.expects(:read).with("/my/catalog.pson").returns "something"
-                Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,'something').returns Puppet::Resource::Catalog.new
-                @puppet.apply
-            end
-
-            it "should read the catalog in from stdin if '-' is provided" do
-                @puppet.options[:catalog] = "-"
-                $stdin.expects(:read).returns "something"
-                Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,'something').returns Puppet::Resource::Catalog.new
-                @puppet.apply
-            end
-
-            it "should deserialize the catalog from the default format" do
-                @puppet.options[:catalog] = "/my/catalog.pson"
-                File.stubs(:read).with("/my/catalog.pson").returns "something"
-                Puppet::Resource::Catalog.stubs(:default_format).returns :rot13_piglatin
-                Puppet::Resource::Catalog.stubs(:convert_from).with(:rot13_piglatin,'something').returns Puppet::Resource::Catalog.new
-                @puppet.apply
-            end
-
-            it "should fail helpfully if deserializing fails" do
-                @puppet.options[:catalog] = "/my/catalog.pson"
-                File.stubs(:read).with("/my/catalog.pson").returns "something syntacically invalid"
-                lambda { @puppet.apply }.should raise_error(Puppet::Error)
-            end
-
-            it "should convert plain data structures into a catalog if deserialization does not do so" do
-                @puppet.options[:catalog] = "/my/catalog.pson"
-                File.stubs(:read).with("/my/catalog.pson").returns "something"
-                Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,"something").returns({:foo => "bar"})
-                Puppet::Resource::Catalog.expects(:pson_create).with({:foo => "bar"}).returns(Puppet::Resource::Catalog.new)
-                @puppet.apply
-            end
-
-            it "should convert the catalog to a RAL catalog and use a Configurer instance to apply it" do
-                @puppet.options[:catalog] = "/my/catalog.pson"
-                File.stubs(:read).with("/my/catalog.pson").returns "something"
-                catalog = Puppet::Resource::Catalog.new
-                Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,'something').returns catalog
-                catalog.expects(:to_ral).returns "mycatalog"
-
-                configurer = stub 'configurer'
-                Puppet::Configurer.expects(:new).returns configurer
-                configurer.expects(:run).with(:catalog => "mycatalog")
-
-                @puppet.apply
-            end
-        end
-    end
-end