puppet 0.25.5 → 2.6.0

data/spec/unit/daemon_spec.rb

@@ -0,0 +1,306 @@
+#!/usr/bin/env ruby"
+
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'puppet/daemon'
+
+def without_warnings
+  flag = $VERBOSE
+  $VERBOSE = nil
+  yield
+  $VERBOSE = flag
+end
+
+describe Puppet::Daemon do
+  before do
+    @daemon = Puppet::Daemon.new
+  end
+
+  it "should be able to manage an agent" do
+    @daemon.should respond_to(:agent)
+  end
+
+  it "should be able to manage a network server" do
+    @daemon.should respond_to(:server)
+  end
+
+  it "should reopen the Log logs when told to reopen logs" do
+    Puppet::Util::Log.expects(:reopen)
+    @daemon.reopen_logs
+  end
+
+  describe "when setting signal traps" do
+    before do
+      @daemon.stubs(:trap)
+    end
+
+    {:INT => :stop, :TERM => :stop, :HUP => :restart, :USR1 => :reload, :USR2 => :reopen_logs}.each do |signal, method|
+      it "should log and call #{method} when it receives #{signal}" do
+        @daemon.expects(:trap).with(signal).yields
+
+        Puppet.expects(:notice)
+
+        @daemon.expects(method)
+
+        @daemon.set_signal_traps
+      end
+    end
+  end
+
+  describe "when starting" do
+    before do
+      @daemon.stubs(:create_pidfile)
+      @daemon.stubs(:set_signal_traps)
+      EventLoop.current.stubs(:run)
+    end
+
+    it "should fail if it has neither agent nor server" do
+      lambda { @daemon.start }.should raise_error(Puppet::DevError)
+    end
+
+    it "should create its pidfile" do
+      @daemon.stubs(:agent).returns stub('agent', :start => nil)
+
+      @daemon.expects(:create_pidfile)
+      @daemon.start
+    end
+
+    it "should start the agent if the agent is configured" do
+      agent = mock 'agent'
+      agent.expects(:start)
+      @daemon.stubs(:agent).returns agent
+
+      @daemon.start
+    end
+
+    it "should start its server if one is configured" do
+      server = mock 'server'
+      server.expects(:start)
+      @daemon.stubs(:server).returns server
+
+      @daemon.start
+    end
+
+    it "should let the current EventLoop run" do
+      @daemon.stubs(:agent).returns stub('agent', :start => nil)
+      EventLoop.current.expects(:run)
+
+      @daemon.start
+    end
+  end
+
+  describe "when stopping" do
+    before do
+      @daemon.stubs(:remove_pidfile)
+      @daemon.stubs(:exit)
+      Puppet::Util::Log.stubs(:close_all)
+      # to make the global safe to mock, set it to a subclass of itself,
+      # then restore it in an after pass
+      without_warnings { Puppet::Application = Class.new(Puppet::Application) }
+    end
+
+    after do
+      # restore from the superclass so we lose the stub garbage
+      without_warnings { Puppet::Application = Puppet::Application.superclass }
+    end
+
+    it "should stop its server if one is configured" do
+      server = mock 'server'
+      server.expects(:stop)
+      @daemon.stubs(:server).returns server
+
+      @daemon.stop
+    end
+
+    it 'should request a stop from Puppet::Application' do
+      Puppet::Application.expects(:stop!)
+      @daemon.stop
+    end
+
+    it "should remove its pidfile" do
+      @daemon.expects(:remove_pidfile)
+
+      @daemon.stop
+    end
+
+    it "should close all logs" do
+      Puppet::Util::Log.expects(:close_all)
+
+      @daemon.stop
+    end
+
+    it "should exit unless called with ':exit => false'" do
+      @daemon.expects(:exit)
+      @daemon.stop
+    end
+
+    it "should not exit if called with ':exit => false'" do
+      @daemon.expects(:exit).never
+      @daemon.stop :exit => false
+    end
+  end
+
+  describe "when creating its pidfile" do
+    it "should use an exclusive mutex" do
+      Puppet.settings.expects(:value).with(:name).returns "me"
+
+      sync = mock 'sync'
+      Puppet::Util.expects(:sync).with("me").returns sync
+
+      sync.expects(:synchronize).with(Sync::EX)
+      @daemon.create_pidfile
+    end
+
+    it "should lock the pidfile using the Pidlock class" do
+      pidfile = mock 'pidfile'
+
+      Puppet.settings.stubs(:value).with(:name).returns "eh"
+      Puppet.settings.expects(:value).with(:pidfile).returns "/my/file"
+
+      Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
+
+      pidfile.expects(:lock).returns true
+      @daemon.create_pidfile
+    end
+
+    it "should fail if it cannot lock" do
+      pidfile = mock 'pidfile'
+
+      Puppet.settings.stubs(:value).with(:name).returns "eh"
+      Puppet.settings.stubs(:value).with(:pidfile).returns "/my/file"
+
+      Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
+
+      pidfile.expects(:lock).returns false
+
+      lambda { @daemon.create_pidfile }.should raise_error
+    end
+  end
+
+  describe "when removing its pidfile" do
+    it "should use an exclusive mutex" do
+      Puppet.settings.expects(:value).with(:name).returns "me"
+
+      sync = mock 'sync'
+      Puppet::Util.expects(:sync).with("me").returns sync
+
+      sync.expects(:synchronize).with(Sync::EX)
+      @daemon.remove_pidfile
+    end
+
+    it "should do nothing if the pidfile is not present" do
+      pidfile = mock 'pidfile', :locked? => false
+      Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
+
+      Puppet.settings.stubs(:value).with(:name).returns "eh"
+      Puppet.settings.stubs(:value).with(:pidfile).returns "/my/file"
+
+      pidfile.expects(:unlock).never
+      @daemon.remove_pidfile
+    end
+
+    it "should unlock the pidfile using the Pidlock class" do
+      pidfile = mock 'pidfile', :locked? => true
+      Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
+      pidfile.expects(:unlock).returns true
+
+      Puppet.settings.stubs(:value).with(:name).returns "eh"
+      Puppet.settings.stubs(:value).with(:pidfile).returns "/my/file"
+
+      @daemon.remove_pidfile
+    end
+
+    it "should warn if it cannot remove the pidfile" do
+      pidfile = mock 'pidfile', :locked? => true
+      Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
+      pidfile.expects(:unlock).returns false
+
+      Puppet.settings.stubs(:value).with(:name).returns "eh"
+      Puppet.settings.stubs(:value).with(:pidfile).returns "/my/file"
+
+      Puppet.expects :err
+      @daemon.remove_pidfile
+    end
+  end
+
+  describe "when reloading" do
+    it "should do nothing if no agent is configured" do
+      @daemon.reload
+    end
+
+    it "should do nothing if the agent is running" do
+      agent = mock 'agent'
+      agent.expects(:running?).returns true
+
+      @daemon.stubs(:agent).returns agent
+
+      @daemon.reload
+    end
+
+    it "should run the agent if one is available and it is not running" do
+      agent = mock 'agent'
+      agent.expects(:running?).returns false
+      agent.expects :run
+
+      @daemon.stubs(:agent).returns agent
+
+      @daemon.reload
+    end
+  end
+
+  describe "when restarting" do
+    before do
+      without_warnings { Puppet::Application = Class.new(Puppet::Application) }
+    end
+
+    after do
+      without_warnings { Puppet::Application = Puppet::Application.superclass }
+    end
+
+    it 'should set Puppet::Application.restart!' do
+      Puppet::Application.expects(:restart!)
+      @daemon.stubs(:reexec)
+      @daemon.restart
+    end
+
+    it "should reexec itself if no agent is available" do
+      @daemon.expects(:reexec)
+
+      @daemon.restart
+    end
+
+    it "should reexec itself if the agent is not running" do
+      agent = mock 'agent'
+      agent.expects(:running?).returns false
+      @daemon.stubs(:agent).returns agent
+      @daemon.expects(:reexec)
+
+      @daemon.restart
+    end
+  end
+
+  describe "when reexecing it self" do
+    before do
+      @daemon.stubs(:exec)
+      @daemon.stubs(:stop)
+    end
+
+    it "should fail if no argv values are available" do
+      @daemon.expects(:argv).returns nil
+      lambda { @daemon.reexec }.should raise_error(Puppet::DevError)
+    end
+
+    it "should shut down without exiting" do
+      @daemon.argv = %w{foo}
+      @daemon.expects(:stop).with(:exit => false)
+
+      @daemon.reexec
+    end
+
+    it "should call 'exec' with the original executable and arguments" do
+      @daemon.argv = %w{foo}
+      @daemon.expects(:exec).with($0 + " foo")
+
+      @daemon.reexec
+    end
+  end
+end

data/spec/unit/dsl/resource_api_spec.rb

@@ -0,0 +1,181 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/dsl/resource_api'
+
+describe Puppet::DSL::ResourceAPI do
+  before do
+    @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
+    @scope = Puppet::Parser::Scope.new(:compiler => @compiler, :source => "foo")
+    @resource = Puppet::Parser::Resource.new(:mytype, "myresource", :scope => @scope)
+    @api = Puppet::DSL::ResourceAPI.new(@resource, @scope, proc { })
+  end
+
+  it "should include the resource type collection helper" do
+    Puppet::DSL::ResourceAPI.ancestors.should be_include(Puppet::Resource::TypeCollectionHelper)
+  end
+
+  it "should use the scope's environment as its environment" do
+    @scope.expects(:environment).returns "myenv"
+    @api.environment.should == "myenv"
+  end
+
+  it "should be able to set all of its parameters as instance variables" do
+    @resource["foo"] = "myval"
+    @api.set_instance_variables
+    @api.instance_variable_get("@foo").should == "myval"
+  end
+
+  describe "when calling a function" do
+    it "should return false if the function does not exist" do
+      Puppet::Parser::Functions.expects(:function).with("myfunc").returns nil
+      @api.call_function("myfunc", "foo").should be_false
+    end
+
+    it "should use the scope the call the provided function with the provided arguments and return the results" do
+      scope = stub 'scope'
+      @api.stubs(:scope).returns scope
+      Puppet::Parser::Functions.expects(:function).with("myfunc").returns "myfunc_method"
+
+      scope.expects(:myfunc_method).with("one", "two")
+      @api.call_function("myfunc", ["one", "two"])
+    end
+
+    it "should call 'include' when asked to call 'acquire'" do
+      scope = stub 'scope'
+      @api.stubs(:scope).returns scope
+      @api.stubs(:valid_type?).returns false
+
+      scope.expects(:function_include).with("one", "two")
+      @api.acquire("one", "two")
+    end
+  end
+
+  describe "when determining if a provided name is a valid type" do
+    it "should be valid if it's :class" do
+      @api.should be_valid_type(:class)
+    end
+
+    it "should be valid if it's :node" do
+      @api.should be_valid_type(:node)
+    end
+
+    it "should be valid if it's a builtin type" do
+      Puppet::Type.expects(:type).with(:mytype).returns "whatever"
+      @api.should be_valid_type(:mytype)
+    end
+
+    it "should be valid if it's a defined resource type in the environment's known resource types" do
+      collection = stub 'collection'
+      @api.stubs(:known_resource_types).returns collection
+      collection.expects(:definition).with(:mytype).returns "whatever"
+      @api.should be_valid_type(:mytype)
+    end
+
+    it "should not be valid unless it's a node, class, builtin type, or defined resource" do
+      collection = stub 'collection'
+      @api.stubs(:known_resource_types).returns collection
+      collection.expects(:definition).returns nil
+      Puppet::Type.expects(:type).returns nil
+      @api.should_not be_valid_type(:mytype)
+    end
+  end
+
+  describe "when creating a resource" do
+    before do
+      @api.scope.stubs(:source).returns stub("source")
+      @api.scope.compiler.stubs(:add_resource)
+      @created_resource = Puppet::Parser::Resource.new("yay", "eh", :scope => @api.scope)
+    end
+
+    it "should create and return a resource of the type specified" do
+      Puppet::Parser::Resource.expects(:new).with { |type, title, args| type == "mytype" }.returns @created_resource
+      @api.create_resource("mytype", "myname", {:foo => "bar"}).should == [@created_resource]
+    end
+
+    it "should use the name from the first element of the provided argument array" do
+      Puppet::Parser::Resource.expects(:new).with { |type, title, args| title == "myname" }.returns @created_resource
+      @api.create_resource("mytype", "myname", {:foo => "bar"})
+    end
+
+    it "should create multiple resources if the first element of the argument array is an array" do
+      second_resource = Puppet::Parser::Resource.new('yay', "eh", :scope => @api.scope)
+      Puppet::Parser::Resource.expects(:new).with { |type, title, args| title == "first" }.returns @created_resource
+      Puppet::Parser::Resource.expects(:new).with { |type, title, args| title == "second" }.returns @created_resource
+      @api.create_resource("mytype", ["first", "second"], {:foo => "bar"})
+    end
+
+    it "should provide its scope as the scope" do
+      Puppet::Parser::Resource.expects(:new).with { |type, title, args| args[:scope] == @api.scope }.returns @created_resource
+      @api.create_resource("mytype", "myname", {:foo => "bar"})
+    end
+
+    it "should set each provided argument as a parameter on the created resource" do
+      result = @api.create_resource("mytype", "myname", {"foo" => "bar", "biz" => "baz"}).shift
+      result["foo"].should == "bar"
+      result["biz"].should == "baz"
+    end
+
+    it "should add the resource to the scope's copmiler" do
+      Puppet::Parser::Resource.expects(:new).returns @created_resource
+      @api.scope.compiler.expects(:add_resource).with(@api.scope, @created_resource)
+      @api.create_resource("mytype", "myname", {:foo => "bar"})
+    end
+
+    it "should fail if the resource parameters are not a hash" do
+      lambda { @api.create_resource("mytype", "myname", %w{foo bar}) }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "when an unknown method is called" do
+    it "should create a resource if the method name is a valid type" do
+      @api.expects(:valid_type?).with(:mytype).returns true
+      @api.expects(:create_resource).with(:mytype, "myname", {:foo => "bar"}).returns true
+
+      @api.mytype("myname", :foo => "bar")
+    end
+
+    it "should call any function whose name matches the undefined method if the name is not a valid type" do
+      @api.expects(:valid_type?).with(:myfunc).returns false
+      @api.expects(:create_resource).never
+
+      Puppet::Parser::Functions.expects(:function).with(:myfunc).returns true
+
+      @api.expects(:call_function).with(:myfunc, %w{foo bar})
+
+      @api.myfunc("foo", "bar")
+    end
+
+    it "should raise a method missing error if the method is neither a type nor a function" do
+      @api.expects(:valid_type?).with(:myfunc).returns false
+      @api.expects(:create_resource).never
+
+      Puppet::Parser::Functions.expects(:function).with(:myfunc).returns false
+
+      @api.expects(:call_function).never
+
+      lambda { @api.myfunc("foo", "bar") }.should raise_error(NoMethodError)
+    end
+  end
+
+  it "should mark the specified resource as exported when creating a single exported resource" do
+    resources = @api.export @api.file("/my/file", :ensure => :present)
+    resources[0].should be_exported
+  end
+
+  it "should mark all created resources as exported when creating exported resources using a block" do
+    @compiler.expects(:add_resource).with { |s, res| res.exported == true }
+    @api.export { file "/my/file", :ensure => :present }
+  end
+
+  it "should mark the specified resource as virtual when creating a single virtual resource" do
+    resources = @api.virtual @api.file("/my/file", :ensure => :present)
+    resources[0].should be_virtual
+  end
+
+  it "should mark all created resources as virtual when creating virtual resources using a block" do
+    @compiler.expects(:add_resource).with { |s, res| res.virtual == true }
+    @api.virtual { file "/my/file", :ensure => :present }
+  end
+end