puppet 0.25.5 → 2.6.0

data/spec/unit/agent/locker.rb

@@ -1,100 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-require 'puppet/agent'
-require 'puppet/agent/locker'
-
-class LockerTester
-    include Puppet::Agent::Locker
-end
-
-describe Puppet::Agent::Locker do
-    before do
-        @locker = LockerTester.new
-        @locker.stubs(:lockfile_path).returns "/my/lock"
-    end
-
-    it "should use a Pidlock instance as its lockfile" do
-        @locker.lockfile.should be_instance_of(Puppet::Util::Pidlock)
-    end
-
-    it "should use 'lockfile_path' to determine its lockfile path" do
-        @locker.expects(:lockfile_path).returns "/my/lock"
-        lock = Puppet::Util::Pidlock.new("/my/lock")
-        Puppet::Util::Pidlock.expects(:new).with("/my/lock").returns lock
-
-        @locker.lockfile
-    end
-
-    it "should reuse the same lock file each time" do
-        @locker.lockfile.should equal(@locker.lockfile)
-    end
-
-    it "should use the lock file to anonymously lock the process when disabled" do
-        @locker.lockfile.expects(:lock).with(:anonymous => true)
-
-        @locker.disable
-    end
-
-    it "should use the lock file to anonymously unlock the process when enabled" do
-        @locker.lockfile.expects(:unlock).with(:anonymous => true)
-
-        @locker.enable
-    end
-
-    it "should have a method that yields when a lock is attained" do
-        @locker.lockfile.expects(:lock).returns true
-
-        yielded = false
-        @locker.lock do
-            yielded = true
-        end
-        yielded.should be_true
-    end
-
-    it "should return true when the lock method successfully locked" do
-        @locker.lockfile.expects(:lock).returns true
-
-        @locker.lock {}.should be_true
-    end
-
-    it "should return true when the lock method does not receive the lock" do
-        @locker.lockfile.expects(:lock).returns false
-
-        @locker.lock {}.should be_false
-    end
-
-    it "should not yield when the lock method does not receive the lock" do
-        @locker.lockfile.expects(:lock).returns false
-
-        yielded = false
-        @locker.lock { yielded = true }
-        yielded.should be_false
-    end
-
-    it "should not unlock when a lock was not received" do
-        @locker.lockfile.expects(:lock).returns false
-        @locker.lockfile.expects(:unlock).never
-
-        @locker.lock {}
-    end
-
-    it "should unlock after yielding upon obtaining a lock" do
-        @locker.lockfile.stubs(:lock).returns true
-        @locker.lockfile.expects(:unlock)
-
-        @locker.lock {}
-    end
-
-    it "should unlock after yielding upon obtaining a lock, even if the block throws an exception" do
-        @locker.lockfile.stubs(:lock).returns true
-        @locker.lockfile.expects(:unlock)
-
-        lambda { @locker.lock { raise "foo" } }.should raise_error(RuntimeError)
-    end
-
-    it "should be considered running if the lockfile is locked" do
-        @locker.lockfile.expects(:locked?).returns true
-        @locker.should be_running
-    end
-end

data/spec/unit/agent/runner.rb

@@ -1,118 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-require 'puppet/agent'
-require 'puppet/agent/runner'
-
-describe Puppet::Agent::Runner do
-    before do
-        @runner = Puppet::Agent::Runner.new
-    end
-
-    it "should indirect :runner" do
-        Puppet::Agent::Runner.indirection.name.should == :runner
-    end
-
-    it "should use a configurer agent as its agent" do
-        agent = mock 'agent'
-        Puppet::Agent.expects(:new).with(Puppet::Configurer).returns agent
-
-        @runner.agent.should equal(agent)
-    end
-
-    it "should accept options at initialization" do
-        lambda { Puppet::Agent::Runner.new :background => true }.should_not raise_error
-    end
-
-    it "should default to running in the foreground" do
-        Puppet::Agent::Runner.new.should_not be_background
-    end
-
-    it "should default to its options being an empty hash" do
-        Puppet::Agent::Runner.new.options.should == {}
-    end
-
-    it "should accept :tags for the agent" do
-        Puppet::Agent::Runner.new(:tags => "foo").options[:tags].should == "foo"
-    end
-
-    it "should accept :ignoreschedules for the agent" do
-        Puppet::Agent::Runner.new(:ignoreschedules => true).options[:ignoreschedules].should be_true
-    end
-
-    it "should accept an option to configure it to run in the background" do
-        Puppet::Agent::Runner.new(:background => true).should be_background
-    end
-
-    it "should retain the background option" do
-        Puppet::Agent::Runner.new(:background => true).options[:background].should be_nil
-    end
-
-    it "should not accept arbitrary options" do
-        lambda { Puppet::Agent::Runner.new(:foo => true) }.should raise_error(ArgumentError)
-    end
-
-    describe "when asked to run" do
-        before do
-            @agent = stub 'agent', :run => nil, :running? => false
-            @runner.stubs(:agent).returns @agent
-        end
-
-        it "should run its agent" do
-            agent = stub 'agent2', :running? => false
-            @runner.stubs(:agent).returns agent
-
-            agent.expects(:run)
-
-            @runner.run
-        end
-
-        it "should pass any of its options on to the agent" do
-            @runner.stubs(:options).returns(:foo => :bar)
-            @agent.expects(:run).with(:foo => :bar)
-
-            @runner.run
-        end
-
-        it "should log its run using the provided options" do
-            @runner.expects(:log_run)
-
-            @runner.run
-        end
-
-        it "should set its status to 'already_running' if the agent is already running" do
-            @agent.expects(:running?).returns true
-
-            @runner.run
-
-            @runner.status.should == "running"
-        end
-
-        it "should set its status to 'success' if the agent is run" do
-            @agent.expects(:running?).returns false
-
-            @runner.run
-
-            @runner.status.should == "success"
-        end
-
-        it "should run the agent in a thread if asked to run it in the background" do
-            Thread.expects(:new)
-
-            @runner.expects(:background?).returns true
-
-            @agent.expects(:run).never # because our thread didn't yield
-
-            @runner.run
-        end
-
-        it "should run the agent directly if asked to run it in the foreground" do
-            Thread.expects(:new).never
-
-            @runner.expects(:background?).returns false
-            @agent.expects(:run)
-
-            @runner.run
-        end
-    end
-end

data/spec/unit/application.rb

@@ -1,420 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../spec_helper'
-
-require 'puppet/application'
-require 'puppet'
-require 'getoptlong'
-
-describe Puppet::Application do
-
-    before :each do
-        @app = Puppet::Application.new(:test)
-    end
-
-    it "should have a run entry-point" do
-        @app.should respond_to(:run)
-    end
-
-    it "should have a read accessor to options" do
-        @app.should respond_to(:options)
-    end
-
-    it "should create a default run_setup method" do
-        @app.should respond_to(:run_setup)
-    end
-
-    it "should create a default run_preinit method" do
-        @app.should respond_to(:run_preinit)
-    end
-
-    it "should create a default get_command method" do
-        @app.should respond_to(:get_command)
-    end
-
-    it "should return :main as default get_command" do
-        @app.get_command.should == :main
-    end
-
-    describe "when parsing command-line options" do
-
-        before :each do
-            @argv_bak = ARGV.dup
-            ARGV.clear
-
-            Puppet.settings.stubs(:optparse_addargs).returns([])
-            @app = Puppet::Application.new(:test)
-        end
-
-        after :each do
-            ARGV.clear
-            ARGV << @argv_bak
-        end
-
-        it "should get options from Puppet.settings.optparse_addargs" do
-            Puppet.settings.expects(:optparse_addargs).returns([])
-
-            @app.parse_options
-        end
-
-        it "should add Puppet.settings options to OptionParser" do
-            Puppet.settings.stubs(:optparse_addargs).returns( [["--option","-o", "Funny Option"]])
-
-            @app.opt_parser.expects(:on).with { |*arg| arg == ["--option","-o", "Funny Option"] }
-
-            @app.parse_options
-        end
-
-        it "should ask OptionParser to parse the command-line argument" do
-            @app.opt_parser.expects(:parse!)
-
-            @app.parse_options
-        end
-
-        describe "when using --help" do
-            confine "rdoc" => Puppet.features.usage?
-
-            it "should call RDoc::usage and exit" do
-                @app.expects(:exit)
-                RDoc.expects(:usage).returns(true)
-
-                @app.handle_help(nil)
-            end
-
-        end
-
-        describe "when using --version" do
-            it "should declare a version option" do
-                @app.should respond_to(:handle_version)
-            end
-
-            it "should exit after printing the version" do
-                @app.stubs(:puts)
-
-                lambda { @app.handle_version(nil) }.should raise_error(SystemExit)
-            end
-        end
-
-        describe "when dealing with an argument not declared directly by the application" do
-            it "should pass it to handle_unknown if this method exists" do
-                Puppet.settings.stubs(:optparse_addargs).returns([["--not-handled"]])
-                @app.opt_parser.stubs(:on).yields("value")
-
-                @app.expects(:handle_unknown).with("--not-handled", "value").returns(true)
-
-                @app.parse_options
-            end
-
-            it "should pass it to Puppet.settings if handle_unknown says so" do
-                Puppet.settings.stubs(:optparse_addargs).returns([["--topuppet"]])
-                @app.opt_parser.stubs(:on).yields("value")
-
-                @app.stubs(:handle_unknown).with("--topuppet", "value").returns(false)
-
-                Puppet.settings.expects(:handlearg).with("--topuppet", "value")
-                @app.parse_options
-            end
-
-            it "should pass it to Puppet.settings if there is no handle_unknown method" do
-                Puppet.settings.stubs(:optparse_addargs).returns([["--topuppet"]])
-                @app.opt_parser.stubs(:on).yields("value")
-
-                @app.stubs(:respond_to?).returns(false)
-
-                Puppet.settings.expects(:handlearg).with("--topuppet", "value")
-                @app.parse_options
-            end
-
-            it "should transform boolean false value to string for Puppet.settings" do
-                Puppet.settings.expects(:handlearg).with("--option", "false")
-                @app.handlearg("--option", false)
-            end
-
-            it "should transform boolean true value to string for Puppet.settings" do
-                Puppet.settings.expects(:handlearg).with("--option", "true")
-                @app.handlearg("--option", true)
-            end
-
-            it "should transform boolean option to normal form for Puppet.settings" do
-                Puppet.settings.expects(:handlearg).with("--option", "true")
-                @app.handlearg("--[no-]option", true)
-            end
-
-            it "should transform boolean option to no- form for Puppet.settings" do
-                Puppet.settings.expects(:handlearg).with("--no-option", "false")
-                @app.handlearg("--[no-]option", false)
-            end
-
-        end
-
-        it "should exit if OptionParser raises an error" do
-            $stderr.stubs(:puts)
-            @app.opt_parser.stubs(:parse!).raises(OptionParser::ParseError.new("blah blah"))
-
-            @app.expects(:exit)
-
-            lambda { @app.parse_options }.should_not raise_error
-        end
-
-    end
-
-    describe "when calling default setup" do
-
-        before :each do
-            @app = Puppet::Application.new(:test)
-            @app.stubs(:should_parse_config?).returns(false)
-            @app.options.stubs(:[])
-        end
-
-        [ :debug, :verbose ].each do |level|
-            it "should honor option #{level}" do
-                @app.options.stubs(:[]).with(level).returns(true)
-                Puppet::Util::Log.stubs(:newdestination)
-
-                Puppet::Util::Log.expects(:level=).with(level == :verbose ? :info : :debug)
-
-                @app.run_setup
-            end
-        end
-
-        it "should honor setdest option" do
-            @app.options.stubs(:[]).with(:setdest).returns(false)
-
-            Puppet::Util::Log.expects(:newdestination).with(:syslog)
-
-            @app.run_setup
-        end
-
-    end
-
-    describe "when running" do
-
-        before :each do
-            @app = Puppet::Application.new(:test)
-            @app.stubs(:run_preinit)
-            @app.stubs(:run_setup)
-            @app.stubs(:parse_options)
-        end
-
-        it "should call run_preinit" do
-            @app.stubs(:run_command)
-
-            @app.expects(:run_preinit)
-
-            @app.run
-        end
-
-        it "should call parse_options" do
-            @app.stubs(:run_command)
-
-            @app.expects(:parse_options)
-
-            @app.run
-        end
-
-        it "should call run_command" do
-
-            @app.expects(:run_command)
-
-            @app.run
-        end
-
-        it "should parse Puppet configuration if should_parse_config is called" do
-            @app.stubs(:run_command)
-            @app.should_parse_config
-
-            Puppet.settings.expects(:parse)
-
-            @app.run
-        end
-
-        it "should not parse_option if should_not_parse_config is called" do
-            @app.stubs(:run_command)
-            @app.should_not_parse_config
-
-            Puppet.settings.expects(:parse).never
-
-            @app.run
-        end
-
-        it "should parse Puppet configuration if needed" do
-            @app.stubs(:run_command)
-            @app.stubs(:should_parse_config?).returns(true)
-
-            Puppet.settings.expects(:parse)
-
-            @app.run
-        end
-
-        it "should call the action matching what returned command" do
-            @app.stubs(:get_command).returns(:backup)
-            @app.stubs(:respond_to?).with(:backup).returns(true)
-
-            @app.expects(:backup)
-
-            @app.run
-        end
-
-        it "should call main as the default command" do
-            @app.expects(:main)
-
-            @app.run
-        end
-
-        it "should warn and exit if no command can be called" do
-            $stderr.expects(:puts)
-            @app.expects(:exit).with(1)
-            @app.run
-        end
-
-        it "should raise an error if dispatch returns no command" do
-            @app.stubs(:get_command).returns(nil)
-            $stderr.expects(:puts)
-            @app.expects(:exit).with(1)
-            @app.run
-        end
-
-        it "should raise an error if dispatch returns an invalid command" do
-            @app.stubs(:get_command).returns(:this_function_doesnt_exist)
-            $stderr.expects(:puts)
-            @app.expects(:exit).with(1)
-            @app.run
-        end
-    end
-
-    describe "when metaprogramming" do
-
-        before :each do
-            @app = Puppet::Application.new(:test)
-        end
-
-        it "should create a new method with command" do
-            @app.command(:test) do
-            end
-
-            @app.should respond_to(:test)
-        end
-
-        describe "when calling attr_accessor" do
-            it "should create a reader method" do
-                @app.attr_accessor(:attribute)
-
-                @app.should respond_to(:attribute)
-            end
-
-            it "should create a reader that delegates to instance_variable_get" do
-                @app.attr_accessor(:attribute)
-
-                @app.expects(:instance_variable_get).with(:@attribute)
-                @app.attribute
-            end
-
-            it "should create a writer method" do
-                @app.attr_accessor(:attribute)
-
-                @app.should respond_to(:attribute=)
-            end
-
-            it "should create a writer that delegates to instance_variable_set" do
-                @app.attr_accessor(:attribute)
-
-                @app.expects(:instance_variable_set).with(:@attribute, 1234)
-                @app.attribute=1234
-            end
-        end
-
-        describe "when calling option" do
-            it "should create a new method named after the option" do
-                @app.option("--test1","-t") do
-                end
-
-                @app.should respond_to(:handle_test1)
-            end
-
-            it "should transpose in option name any '-' into '_'" do
-                @app.option("--test-dashes-again","-t") do
-                end
-
-                @app.should respond_to(:handle_test_dashes_again)
-            end
-
-            it "should create a new method called handle_test2 with option(\"--[no-]test2\")" do
-                @app.option("--[no-]test2","-t") do
-                end
-
-                @app.should respond_to(:handle_test2)
-            end
-
-            describe "when a block is passed" do
-                it "should create a new method with it" do
-                    @app.option("--[no-]test2","-t") do
-                        raise "I can't believe it, it works!"
-                    end
-
-                    lambda { @app.handle_test2 }.should raise_error
-                end
-
-                it "should declare the option to OptionParser" do
-                    @app.opt_parser.expects(:on).with { |*arg| arg[0] == "--[no-]test3" }
-
-                    @app.option("--[no-]test3","-t") do
-                    end
-                end
-
-                it "should pass a block that calls our defined method" do
-                    @app.opt_parser.stubs(:on).yields(nil)
-
-                    @app.expects(:send).with(:handle_test4, nil)
-
-                    @app.option("--test4","-t") do
-                    end
-                end
-            end
-
-            describe "when no block is given" do
-                it "should declare the option to OptionParser" do
-                    @app.opt_parser.expects(:on).with("--test4","-t")
-
-                    @app.option("--test4","-t")
-                end
-
-                it "should give to OptionParser a block that adds the the value to the options array" do
-                    @app.opt_parser.stubs(:on).with("--test4","-t").yields(nil)
-
-                    @app.options.expects(:[]=).with(:test4,nil)
-
-                    @app.option("--test4","-t")
-                end
-            end
-        end
-
-        it "should create a method called run_setup with setup" do
-            @app.setup do
-            end
-
-            @app.should respond_to(:run_setup)
-        end
-
-        it "should create a method called run_preinit with preinit" do
-            @app.preinit do
-            end
-
-            @app.should respond_to(:run_preinit)
-        end
-
-        it "should create a method called handle_unknown with unknown" do
-            @app.unknown do
-            end
-
-            @app.should respond_to(:handle_unknown)
-        end
-
-
-        it "should create a method called get_command with dispatch" do
-            @app.dispatch do
-            end
-
-            @app.should respond_to(:get_command)
-        end
-    end
-end