puppet 0.24.6 → 0.24.7

data/spec/unit/file_serving/terminus_helper.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-10-22.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/file_serving/terminus_helper'
+
+describe Puppet::FileServing::TerminusHelper do
+    before do
+        @helper = Object.new
+        @helper.extend(Puppet::FileServing::TerminusHelper)
+
+        @model = mock 'model'
+        @helper.stubs(:model).returns(@model)
+
+        @request = stub 'request', :key => "url", :options => {}
+    end
+
+    it "should use a fileset to find paths" do
+        fileset = mock 'fileset', :files => []
+        Puppet::FileServing::Fileset.expects(:new).with("/my/file", {}).returns(fileset)
+        @helper.path2instances(@request, "/my/file")
+    end
+
+    it "should pass :recurse, :ignore, and :links settings on to the fileset if present" do
+        fileset = mock 'fileset', :files => []
+        Puppet::FileServing::Fileset.expects(:new).with("/my/file", :links => :a, :ignore => :b, :recurse => :c).returns(fileset)
+        @request.stubs(:options).returns(:links => :a, :ignore => :b, :recurse => :c)
+        @helper.path2instances(@request, "/my/file")
+    end
+
+    describe "when creating instances" do
+        before do
+            @request.stubs(:key).returns "puppet://host/mount/dir"
+
+            @fileset = mock 'fileset', :files => %w{one two}
+            Puppet::FileServing::Fileset.expects(:new).returns(@fileset)
+        end
+
+        it "should create an instance of the model for each path returned by the fileset" do
+            @model.expects(:new).returns(:one)
+            @model.expects(:new).returns(:two)
+            @helper.path2instances(@request, "/my/file").length.should == 2
+        end
+
+        it "should set each instance's key to be the original key plus the file-specific path" do
+            @model.expects(:new).with { |key, options| key == @request.key + "/one" }.returns(:one)
+            @model.expects(:new).with { |key, options| key == @request.key + "/two" }.returns(:two)
+            @helper.path2instances(@request, "/my/file")
+        end
+
+        it "should set each returned instance's path to the original path" do
+            @model.expects(:new).with { |key, options| options[:path] == "/my/file" }.returns(:one)
+            @model.expects(:new).with { |key, options| options[:path] == "/my/file" }.returns(:two)
+            @helper.path2instances(@request, "/my/file")
+        end
+
+        it "should set each returned instance's relative path to the file-specific path" do
+            @model.expects(:new).with { |key, options| options[:relative_path] == "one" }.returns(:one)
+            @model.expects(:new).with { |key, options| options[:relative_path] == "two" }.returns(:two)
+            @helper.path2instances(@request, "/my/file")
+        end
+
+        it "should set the links value on each instance if one is provided" do
+            one = mock 'one', :links= => :manage
+            two = mock 'two', :links= => :manage
+            @model.expects(:new).returns(one)
+            @model.expects(:new).returns(two)
+
+            @request.options[:links] = :manage
+            @helper.path2instances(@request, "/my/file")
+        end
+    end
+end

data/spec/unit/indirector.rb

@@ -0,0 +1,152 @@
+#!/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
+
+    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/catalog/compiler.rb

@@ -0,0 +1,156 @@
+#!/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::Node::Catalog::Compiler 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::Node::Catalog::Compiler.new
+    end
+
+    it "should cache the server metadata and reuse it" do
+        compiler = Puppet::Node::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', :key => 'node1', :options => {}))
+        compiler.find(stub('node2request', :key => 'node2', :options => {}))
+    end
+
+    it "should provide a method for determining if the catalog is networked" do
+        compiler = Puppet::Node::Catalog::Compiler.new
+        compiler.should respond_to(:networked?)
+    end
+end
+
+describe Puppet::Node::Catalog::Compiler, " 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::Node::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 Puppet::Node::Catalog::Compiler, " when finding nodes" do
+    before do
+        Facter.stubs(:value).returns("whatever")
+        @compiler = Puppet::Node::Catalog::Compiler.new
+        @name = "me"
+        @node = mock 'node'
+        @request = stub 'request', :key => @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 Puppet::Node::Catalog::Compiler, " 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::Node::Catalog::Compiler.new
+        @name = "me"
+        @node = mock 'node'
+        @request = stub 'request', :key => @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 Puppet::Node::Catalog::Compiler, " when creating catalogs" do
+    before do
+        Facter.stubs(:value).returns("whatever")
+        env = stub 'environment', :name => "yay"
+        Puppet::Node::Environment.stubs(:new).returns(env)
+
+        @compiler = Puppet::Node::Catalog::Compiler.new
+        @name = "me"
+        @node = Puppet::Node.new @name
+        @node.stubs(:merge)
+        @request = stub 'request', :key => @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 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 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 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

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

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/node/catalog'
+require 'puppet/indirector/catalog/yaml'
+
+describe Puppet::Node::Catalog::Yaml do
+    it "should be a subclass of the Yaml terminus" do
+        Puppet::Node::Catalog::Yaml.superclass.should equal(Puppet::Indirector::Yaml)
+    end
+
+    it "should have documentation" do
+        Puppet::Node::Catalog::Yaml.doc.should_not be_nil
+    end
+
+    it "should be registered with the catalog store indirection" do
+        indirection = Puppet::Indirector::Indirection.instance(:catalog)
+        Puppet::Node::Catalog::Yaml.indirection.should equal(indirection)
+    end
+
+    it "should have its name set to :yaml" do
+        Puppet::Node::Catalog::Yaml.name.should == :yaml
+    end
+end

data/spec/unit/indirector/checksum/file.rb

@@ -0,0 +1,139 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2007-9-22.
+#  Copyright (c) 2007. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/indirector/checksum/file'
+
+describe Puppet::Checksum::File do
+    it "should be a subclass of the File terminus class" do
+        Puppet::Checksum::File.superclass.should equal(Puppet::Indirector::File)
+    end
+
+    it "should have documentation" do
+        Puppet::Checksum::File.doc.should be_instance_of(String)
+    end
+end
+
+describe Puppet::Checksum::File, " when initializing" do
+    it "should use the filebucket settings section" do
+        Puppet.settings.expects(:use).with(:filebucket)
+        Puppet::Checksum::File.new
+    end
+end
+
+
+describe Puppet::Checksum::File do
+    before :each do
+        Puppet.settings.stubs(:use)
+        @store = Puppet::Checksum::File.new
+
+        @value = "70924d6fa4b2d745185fa4660703a5c0"
+        @sum = stub 'sum', :name => @value
+
+        @dir = "/what/ever"
+
+        Puppet.stubs(:[]).with(:bucketdir).returns(@dir)
+
+        @path = @store.path(@value)
+
+        @request = stub 'request', :key => @value
+    end
+
+
+    describe Puppet::Checksum::File, " when determining file paths" do
+
+        # I was previously passing the object in.
+        it "should use the value passed in to path() as the checksum" do
+            @value.expects(:name).never
+            @store.path(@value)
+        end
+
+        it "should use the value of the :bucketdir setting as the root directory" do
+            @path.should =~ %r{^#{@dir}}
+        end
+
+        it "should choose a path 8 directories deep with each directory name being the respective character in the checksum" do
+            dirs = @value[0..7].split("").join(File::SEPARATOR)
+            @path.should be_include(dirs)
+        end
+
+        it "should use the full checksum as the final directory name" do
+            File.basename(File.dirname(@path)).should == @value
+        end
+
+        it "should use 'contents' as the actual file name" do
+            File.basename(@path).should == "contents"
+        end
+
+        it "should use the bucketdir, the 8 sum character directories, the full checksum, and 'contents' as the full file name" do
+            @path.should == [@dir, @value[0..7].split(""), @value, "contents"].flatten.join(File::SEPARATOR)
+        end
+    end
+
+    describe Puppet::Checksum::File, " when retrieving files" do
+
+        # The smallest test that will use the calculated path
+        it "should look for the calculated path" do
+            File.expects(:exist?).with(@path).returns(false)
+            @store.find(@request)
+        end
+
+        it "should return an instance of Puppet::Checksum created with the content if the file exists" do
+            content = "my content"
+            sum = stub 'file'
+            Puppet::Checksum.expects(:new).with(content).returns(sum)
+
+            File.expects(:exist?).with(@path).returns(true)
+            File.expects(:read).with(@path).returns(content)
+
+            @store.find(@request).should equal(sum)
+        end
+
+        it "should return nil if no file is found" do
+            File.expects(:exist?).with(@path).returns(false)
+            @store.find(@request).should be_nil
+        end
+
+        it "should fail intelligently if a found file cannot be read" do
+            File.expects(:exist?).with(@path).returns(true)
+            File.expects(:read).with(@path).raises(RuntimeError)
+            proc { @store.find(@request) }.should raise_error(Puppet::Error)
+        end
+    end
+
+    describe Puppet::Checksum::File, " when saving files" do
+
+        # LAK:FIXME I don't know how to include in the spec the fact that we're
+        # using the superclass's save() method and thus are acquiring all of
+        # it's behaviours.
+        it "should save the content to the calculated path" do
+            File.stubs(:directory?).with(File.dirname(@path)).returns(true)
+            File.expects(:open).with(@path, "w")
+
+            file = stub 'file', :name => @value
+            @store.save(@request)
+        end
+
+        it "should make any directories necessary for storage" do
+            FileUtils.expects(:mkdir_p).with do |arg|
+                File.umask == 0007 and arg == File.dirname(@path)
+            end
+            File.expects(:directory?).with(File.dirname(@path)).returns(true)
+            File.expects(:open).with(@path, "w")
+
+            @store.save(@request)
+        end
+    end
+
+    describe Puppet::Checksum::File, " when deleting files" do
+        it "should remove the file at the calculated path" do
+            File.expects(:exist?).with(@path).returns(true)
+            File.expects(:unlink).with(@path)
+
+            @store.destroy(@request)
+        end
+    end
+end