puppet 0.25.5 → 2.6.0

data/spec/unit/indirector.rb

@@ -1,157 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../spec_helper'
-
-require 'puppet/defaults'
-require 'puppet/indirector'
-
-describe Puppet::Indirector, " when available to a model" do
-    before do
-        @thingie = Class.new do
-            extend Puppet::Indirector
-        end
-    end
-
-    it "should provide a way for the model to register an indirection under a name" do
-        @thingie.should respond_to(:indirects)
-    end
-end
-
-describe Puppet::Indirector, "when registering an indirection" do
-    before do
-        @thingie = Class.new do
-            extend Puppet::Indirector
-            attr_reader :name
-            def initialize(name)
-                @name = name
-            end
-        end
-    end
-
-    it "should require a name when registering a model" do
-        Proc.new {@thingie.send(:indirects) }.should raise_error(ArgumentError)
-    end
-
-    it "should create an indirection instance to manage each indirecting model" do
-        @indirection = @thingie.indirects(:test)
-        @indirection.should be_instance_of(Puppet::Indirector::Indirection)
-    end
-
-    it "should not allow a model to register under multiple names" do
-        # Keep track of the indirection instance so we can delete it on cleanup
-        @indirection = @thingie.indirects :first
-        Proc.new { @thingie.indirects :second }.should raise_error(ArgumentError)
-    end
-
-    it "should make the indirection available via an accessor" do
-        @indirection = @thingie.indirects :first
-        @thingie.indirection.should equal(@indirection)
-    end
-
-    it "should pass any provided options to the indirection during initialization" do
-        klass = mock 'terminus class'
-        Puppet::Indirector::Indirection.expects(:new).with(@thingie, :first, {:some => :options})
-        @indirection = @thingie.indirects :first, :some => :options
-    end
-
-    it "should extend the class with the Format Handler" do
-        @indirection = @thingie.indirects :first
-        @thingie.metaclass.ancestors.should be_include(Puppet::Network::FormatHandler)
-    end
-
-    after do
-        @indirection.delete if @indirection
-    end
-end
-
-describe "Delegated Indirection Method", :shared => true do
-    it "should delegate to the indirection" do
-        @indirection.expects(@method)
-        @thingie.send(@method, "me")
-    end
-
-    it "should pass all of the passed arguments directly to the indirection instance" do
-        @indirection.expects(@method).with("me", :one => :two)
-        @thingie.send(@method, "me", :one => :two)
-    end
-
-    it "should return the results of the delegation as its result" do
-        request = mock 'request'
-        @indirection.expects(@method).returns "yay"
-        @thingie.send(@method, "me").should == "yay"
-    end
-end
-
-describe Puppet::Indirector, "when redirecting a model" do
-    before do
-        @thingie = Class.new do
-            extend Puppet::Indirector
-            attr_reader :name
-            def initialize(name)
-                @name = name
-            end
-        end
-        @indirection = @thingie.send(:indirects, :test)
-    end
-
-    it "should include the Envelope module in the model" do
-        @thingie.ancestors.should be_include(Puppet::Indirector::Envelope)
-    end
-
-    describe "when finding instances via the model" do
-        before { @method = :find }
-        it_should_behave_like "Delegated Indirection Method"
-    end
-
-    describe "when destroying instances via the model" do
-        before { @method = :destroy }
-        it_should_behave_like "Delegated Indirection Method"
-    end
-
-    describe "when searching for instances via the model" do
-        before { @method = :search }
-        it_should_behave_like "Delegated Indirection Method"
-    end
-
-    describe "when expiring instances via the model" do
-        before { @method = :expire }
-        it_should_behave_like "Delegated Indirection Method"
-    end
-
-    # This is an instance method, so it behaves a bit differently.
-    describe "when saving instances via the model" do
-        before do
-            @instance = @thingie.new("me")
-        end
-
-        it "should delegate to the indirection" do
-            @indirection.expects(:save)
-            @instance.save
-        end
-
-        it "should pass the instance and all arguments to the indirection's :save method" do
-            @indirection.expects(:save).with(@instance, :one => :two)
-            @instance.save :one => :two
-        end
-
-        it "should return the results of the delegation as its result" do
-            request = mock 'request'
-            @indirection.expects(:save).returns "yay"
-            @instance.save.should == "yay"
-        end
-    end
-
-    it "should give the model the ability to set the indirection terminus class" do
-        @indirection.expects(:terminus_class=).with(:myterm)
-        @thingie.terminus_class = :myterm
-    end
-
-    it "should give the model the ability to set the indirection cache class" do
-        @indirection.expects(:cache_class=).with(:mycache)
-        @thingie.cache_class = :mycache
-    end
-
-    after do
-        @indirection.delete
-    end
-end

data/spec/unit/indirector/active_record.rb

@@ -1,76 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require 'puppet/indirector/active_record'
-
-describe Puppet::Indirector::ActiveRecord do
-    before do
-        Puppet::Rails.stubs(:init)
-
-        Puppet::Indirector::Terminus.stubs(:register_terminus_class)
-        @model = mock 'model'
-        @indirection = stub 'indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model
-        Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
-
-        @active_record_class = Class.new(Puppet::Indirector::ActiveRecord) do
-            def self.to_s
-                "Mystuff::Testing"
-            end
-        end
-
-        @ar_model = mock 'ar_model'
-
-        @active_record_class.use_ar_model @ar_model
-        @terminus = @active_record_class.new
-
-        @name = "me"
-        @instance = stub 'instance', :name => @name
-
-        @request = stub 'request', :key => @name, :instance => @instance
-    end
-
-    it "should allow declaration of an ActiveRecord model to use" do
-        @active_record_class.use_ar_model "foo"
-        @active_record_class.ar_model.should == "foo"
-    end
-
-    describe "when initializing" do
-        it "should init Rails" do
-            Puppet::Rails.expects(:init)
-            @active_record_class.new
-        end
-    end
-
-    describe "when finding an instance" do
-        it "should use the ActiveRecord model to find the instance" do
-            @ar_model.expects(:find_by_name).with(@name)
-
-            @terminus.find(@request)
-        end
-
-        it "should return nil if no instance is found" do
-            @ar_model.expects(:find_by_name).with(@name).returns nil
-            @terminus.find(@request).should be_nil
-        end
-
-        it "should convert the instance to a Puppet object if it is found" do
-            instance = mock 'rails_instance'
-            instance.expects(:to_puppet).returns "mypuppet"
-
-            @ar_model.expects(:find_by_name).with(@name).returns instance
-            @terminus.find(@request).should == "mypuppet"
-        end
-    end
-
-    describe "when saving an instance" do
-        it "should use the ActiveRecord model to convert the instance into a Rails object and then save that rails object" do
-            rails_object = mock 'rails_object'
-            @ar_model.expects(:from_puppet).with(@instance).returns rails_object
-
-            rails_object.expects(:save)
-
-            @terminus.save(@request)
-        end
-    end
-end

data/spec/unit/indirector/catalog/active_record.rb

@@ -1,141 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-
-describe "Puppet::Resource::Catalog::ActiveRecord" do
-    confine "Missing Rails" => Puppet.features.rails?
-
-    before do
-        require 'puppet/indirector/catalog/active_record'
-        Puppet.features.stubs(:rails?).returns true
-        Puppet::Rails.stubs(:init)
-        @terminus = Puppet::Resource::Catalog::ActiveRecord.new
-    end
-
-    it "should be a subclass of the ActiveRecord terminus class" do
-        Puppet::Resource::Catalog::ActiveRecord.ancestors.should be_include(Puppet::Indirector::ActiveRecord)
-    end
-
-    it "should use Puppet::Rails::Host as its ActiveRecord model" do
-        Puppet::Resource::Catalog::ActiveRecord.ar_model.should equal(Puppet::Rails::Host)
-    end
-
-    describe "when finding an instance" do
-        before do
-            @request = stub 'request', :key => "foo", :options => {:cache_integration_hack => true}
-        end
-
-        # This hack is here because we don't want to look in the db unless we actually want
-        # to look in the db, but our indirection architecture in 0.24.x isn't flexible
-        # enough to tune that via configuration.
-        it "should return nil unless ':cache_integration_hack' is set to true" do
-            @request.options[:cache_integration_hack] = false
-            Puppet::Rails::Host.expects(:find_by_name).never
-            @terminus.find(@request).should be_nil
-        end
-
-        it "should use the Hosts ActiveRecord class to find the host" do
-            Puppet::Rails::Host.expects(:find_by_name).with { |key, args| key == "foo" }
-            @terminus.find(@request)
-        end
-
-        it "should return nil if no host instance can be found" do
-            Puppet::Rails::Host.expects(:find_by_name).returns nil
-
-            @terminus.find(@request).should be_nil
-        end
-
-        it "should return a catalog with the same name as the host if the host can be found" do
-            host = stub 'host', :name => "foo", :resources => []
-            Puppet::Rails::Host.expects(:find_by_name).returns host
-
-            result = @terminus.find(@request)
-            result.should be_instance_of(Puppet::Resource::Catalog)
-            result.name.should == "foo"
-        end
-
-        it "should set each of the host's resources as a transportable resource within the catalog" do
-            host = stub 'host', :name => "foo"
-            Puppet::Rails::Host.expects(:find_by_name).returns host
-
-            res1 = mock 'res1', :to_transportable => "trans_res1"
-            res2 = mock 'res2', :to_transportable => "trans_res2"
-
-            host.expects(:resources).returns [res1, res2]
-
-            catalog = stub 'catalog'
-            Puppet::Resource::Catalog.expects(:new).returns catalog
-
-            catalog.expects(:add_resource).with "trans_res1"
-            catalog.expects(:add_resource).with "trans_res2"
-
-            @terminus.find(@request)
-        end
-    end
-
-    describe "when saving an instance" do
-        before do
-            @host = stub 'host', :name => "foo", :save => nil, :merge_resources => nil, :last_compile= => nil, :ip= => nil, :environment= => nil
-            @host.stubs(:railsmark).yields
-
-            @node = stub_everything 'node', :parameters => {}
-            Puppet::Node.stubs(:find).returns(@node)
-
-            Puppet::Rails::Host.stubs(:find_by_name).returns @host
-            @catalog = Puppet::Resource::Catalog.new("foo")
-            @request = stub 'request', :key => "foo", :instance => @catalog
-        end
-
-        it "should find the Rails host with the same name" do
-            Puppet::Rails::Host.expects(:find_by_name).with("foo").returns @host
-
-            @terminus.save(@request)
-        end
-
-        it "should create a new Rails host if none can be found" do
-            Puppet::Rails::Host.expects(:find_by_name).with("foo").returns nil
-
-            Puppet::Rails::Host.expects(:create).with(:name => "foo").returns @host
-
-            @terminus.save(@request)
-        end
-
-        it "should set the catalog vertices as resources on the Rails host instance" do
-            @catalog.expects(:vertices).returns "foo"
-            @host.expects(:merge_resources).with("foo")
-
-            @terminus.save(@request)
-        end
-
-        it "should set host ip if we could find a matching node" do
-            @node.stubs(:parameters).returns({"ipaddress" => "192.168.0.1"})
-
-            @host.expects(:ip=).with '192.168.0.1'
-
-            @terminus.save(@request)
-        end
-
-        it "should set host environment if we could find a matching node" do
-            @node.stubs(:environment).returns("myenv")
-
-            @host.expects(:environment=).with 'myenv'
-
-            @terminus.save(@request)
-        end
-
-        it "should set the last compile time on the host" do
-            now = Time.now
-            Time.expects(:now).returns now
-            @host.expects(:last_compile=).with now
-
-            @terminus.save(@request)
-        end
-
-        it "should save the Rails host instance" do
-            @host.expects(:save)
-
-            @terminus.save(@request)
-        end
-    end
-end

data/spec/unit/indirector/catalog/compiler.rb

@@ -1,261 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Luke Kanies on 2007-9-23.
-#  Copyright (c) 2007. All rights reserved.
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-require 'puppet/indirector/catalog/compiler'
-
-describe Puppet::Resource::Catalog::Compiler do
-    describe "when initializing" do
-        before do
-            Puppet.expects(:version).returns(1)
-            Facter.expects(:value).with('fqdn').returns("my.server.com")
-            Facter.expects(:value).with('ipaddress').returns("my.ip.address")
-        end
-
-        it "should gather data about itself" do
-            Puppet::Resource::Catalog::Compiler.new
-        end
-
-        it "should cache the server metadata and reuse it" do
-            compiler = Puppet::Resource::Catalog::Compiler.new
-            node1 = stub 'node1', :merge => nil
-            node2 = stub 'node2', :merge => nil
-            compiler.stubs(:compile)
-            Puppet::Node.stubs(:find).with('node1').returns(node1)
-            Puppet::Node.stubs(:find).with('node2').returns(node2)
-
-            compiler.find(stub('request', :node => 'node1', :options => {}))
-            compiler.find(stub('node2request', :node => 'node2', :options => {}))
-        end
-
-        it "should provide a method for determining if the catalog is networked" do
-            compiler = Puppet::Resource::Catalog::Compiler.new
-            compiler.should respond_to(:networked?)
-        end
-    end
-
-    describe "when creating the interpreter" do
-        before do
-            # This gets pretty annoying on a plane where we have no IP address
-            Facter.stubs(:value).returns("whatever")
-            @compiler = Puppet::Resource::Catalog::Compiler.new
-        end
-
-        it "should not create the interpreter until it is asked for the first time" do
-            interp = mock 'interp'
-            Puppet::Parser::Interpreter.expects(:new).with().returns(interp)
-            @compiler.interpreter.should equal(interp)
-        end
-
-        it "should use the same interpreter for all compiles" do
-            interp = mock 'interp'
-            Puppet::Parser::Interpreter.expects(:new).with().returns(interp)
-            @compiler.interpreter.should equal(interp)
-            @compiler.interpreter.should equal(interp)
-        end
-    end
-
-    describe "when finding catalogs" do
-        before do
-            Facter.stubs(:value).returns("whatever")
-            env = stub 'environment', :name => "yay", :modulepath => []
-            Puppet::Node::Environment.stubs(:new).returns(env)
-
-            @compiler = Puppet::Resource::Catalog::Compiler.new
-            @name = "me"
-            @node = Puppet::Node.new @name
-            @node.stubs(:merge)
-            @request = stub 'request', :key => "does not matter", :node => @name, :options => {}
-        end
-
-        it "should directly use provided nodes" do
-            Puppet::Node.expects(:find).never
-            @compiler.expects(:compile).with(@node)
-            @request.stubs(:options).returns(:use_node => @node)
-            @compiler.find(@request)
-        end
-
-        it "should use the request's node name if no explicit node is provided" do
-            Puppet::Node.expects(:find).with(@name).returns(@node)
-            @compiler.expects(:compile).with(@node)
-            @compiler.find(@request)
-        end
-
-        it "should use the provided node name if no explicit node is provided and no authenticated node information is available" do
-            @request.expects(:node).returns nil
-            @request.expects(:key).returns "my_node"
-
-            Puppet::Node.expects(:find).with("my_node").returns @node
-            @compiler.expects(:compile).with(@node)
-            @compiler.find(@request)
-        end
-
-        it "should fail if no node is passed and none can be found" do
-            Puppet::Node.stubs(:find).with(@name).returns(nil)
-            proc { @compiler.find(@request) }.should raise_error(ArgumentError)
-        end
-
-        it "should fail intelligently when searching for a node raises an exception" do
-            Puppet::Node.stubs(:find).with(@name).raises "eh"
-            proc { @compiler.find(@request) }.should raise_error(Puppet::Error)
-        end
-
-        it "should pass the found node to the interpreter for compiling" do
-            Puppet::Node.expects(:find).with(@name).returns(@node)
-            config = mock 'config'
-            @compiler.interpreter.expects(:compile).with(@node)
-            @compiler.find(@request)
-        end
-
-        it "should extract and save any facts from the request" do
-            Puppet::Node.expects(:find).with(@name).returns @node
-            @compiler.expects(:extract_facts_from_request).with(@request)
-            @compiler.interpreter.stubs(:compile)
-            @compiler.find(@request)
-        end
-
-        it "should return the results of compiling as the catalog" do
-            Puppet::Node.stubs(:find).returns(@node)
-            config = mock 'config'
-            result = mock 'result'
-
-            @compiler.interpreter.expects(:compile).with(@node).returns(result)
-            @compiler.find(@request).should equal(result)
-        end
-
-        it "should benchmark the compile process" do
-            Puppet::Node.stubs(:find).returns(@node)
-            @compiler.stubs(:networked?).returns(true)
-            @compiler.expects(:benchmark).with do |level, message|
-                level == :notice and message =~ /^Compiled catalog/
-            end
-            @compiler.interpreter.stubs(:compile).with(@node)
-            @compiler.find(@request)
-        end
-    end
-
-    describe "when extracting facts from the request" do
-        before do
-            @compiler = Puppet::Resource::Catalog::Compiler.new
-            @request = stub 'request', :options => {}
-
-            @facts = stub 'facts', :save => nil
-        end
-
-        it "should do nothing if no facts are provided" do
-            Puppet::Node::Facts.expects(:convert_from).never
-            @request.options[:facts] = nil
-
-            @compiler.extract_facts_from_request(@request)
-        end
-
-        it "should use the Facts class to deserialize the provided facts" do
-            @request.options[:facts_format] = "foo"
-            @request.options[:facts] = "bar"
-            Puppet::Node::Facts.expects(:convert_from).returns @facts
-
-            @compiler.extract_facts_from_request(@request)
-        end
-
-        it "should use the provided fact format" do
-            @request.options[:facts_format] = "foo"
-            @request.options[:facts] = "bar"
-            Puppet::Node::Facts.expects(:convert_from).with { |format, text| format == "foo" }.returns @facts
-
-            @compiler.extract_facts_from_request(@request)
-        end
-
-        it "should convert the facts into a fact instance and save it" do
-            @request.options[:facts_format] = "foo"
-            @request.options[:facts] = "bar"
-            Puppet::Node::Facts.expects(:convert_from).returns @facts
-
-            @facts.expects(:save)
-
-            @compiler.extract_facts_from_request(@request)
-        end
-    end
-
-    describe "when finding nodes" do
-        before do
-            Facter.stubs(:value).returns("whatever")
-            @compiler = Puppet::Resource::Catalog::Compiler.new
-            @name = "me"
-            @node = mock 'node'
-            @request = stub 'request', :node => @name, :options => {}
-            @compiler.stubs(:compile)
-        end
-
-        it "should look node information up via the Node class with the provided key" do
-            @node.stubs :merge
-            Puppet::Node.expects(:find).with(@name).returns(@node)
-            @compiler.find(@request)
-        end
-    end
-
-    describe "after finding nodes" do
-        before do
-            Puppet.expects(:version).returns(1)
-            Facter.expects(:value).with('fqdn').returns("my.server.com")
-            Facter.expects(:value).with('ipaddress').returns("my.ip.address")
-            @compiler = Puppet::Resource::Catalog::Compiler.new
-            @name = "me"
-            @node = mock 'node'
-            @request = stub 'request', :node => @name, :options => {}
-            @compiler.stubs(:compile)
-            Puppet::Node.stubs(:find).with(@name).returns(@node)
-        end
-
-        it "should add the server's Puppet version to the node's parameters as 'serverversion'" do
-            @node.expects(:merge).with { |args| args["serverversion"] == "1" }
-            @compiler.find(@request)
-        end
-
-        it "should add the server's fqdn to the node's parameters as 'servername'" do
-            @node.expects(:merge).with { |args| args["servername"] == "my.server.com" }
-            @compiler.find(@request)
-        end
-
-        it "should add the server's IP address to the node's parameters as 'serverip'" do
-            @node.expects(:merge).with { |args| args["serverip"] == "my.ip.address" }
-            @compiler.find(@request)
-        end
-    end
-
-    describe "when filtering resources" do
-        before :each do
-            @compiler = Puppet::Resource::Catalog::Compiler.new
-            @catalog = stub_everything 'catalog'
-            @catalog.stubs(:respond_to?).with(:filter).returns(true)
-        end
-
-        it "should delegate to the catalog instance filtering" do
-            @catalog.expects(:filter)
-            @compiler.filter(@catalog)
-        end
-
-        it "should filter out virtual resources" do
-            resource = mock 'resource', :virtual? => true
-            @catalog.stubs(:filter).yields(resource)
-
-            @compiler.filter(@catalog)
-        end
-
-        it "should return the same catalog if it doesn't support filtering" do
-            @catalog.stubs(:respond_to?).with(:filter).returns(false)
-
-            @compiler.filter(@catalog).should == @catalog
-        end
-
-        it "should return the filtered catalog" do
-            catalog = stub 'filtered catalog'
-            @catalog.stubs(:filter).returns(catalog)
-
-            @compiler.filter(@catalog).should == catalog
-        end
-
-    end
-end