puppet 0.25.5 → 2.6.0

data/spec/unit/indirector/terminus.rb

@@ -1,245 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-require 'puppet/defaults'
-require 'puppet/indirector'
-require 'puppet/indirector/file'
-
-describe Puppet::Indirector::Terminus do
-    before :each do
-        Puppet::Indirector::Terminus.stubs(:register_terminus_class)
-        @indirection = stub 'indirection', :name => :my_stuff, :register_terminus_type => nil
-        Puppet::Indirector::Indirection.stubs(:instance).with(:my_stuff).returns(@indirection)
-        @abstract_terminus = Class.new(Puppet::Indirector::Terminus) do
-            def self.to_s
-                "Testing::Abstract"
-            end
-        end
-        @terminus_class = Class.new(@abstract_terminus) do
-            def self.to_s
-                "MyStuff::TermType"
-            end
-        end
-        @terminus = @terminus_class.new
-    end
-
-    describe Puppet::Indirector::Terminus do
-
-        it "should provide a method for setting terminus class documentation" do
-            @terminus_class.should respond_to(:desc)
-        end
-
-        it "should support a class-level name attribute" do
-            @terminus_class.should respond_to(:name)
-        end
-
-        it "should support a class-level indirection attribute" do
-            @terminus_class.should respond_to(:indirection)
-        end
-
-        it "should support a class-level terminus-type attribute" do
-            @terminus_class.should respond_to(:terminus_type)
-        end
-
-        it "should support a class-level model attribute" do
-            @terminus_class.should respond_to(:model)
-        end
-
-        it "should accept indirection instances as its indirection" do
-            indirection = stub 'indirection', :is_a? => true, :register_terminus_type => nil
-            proc { @terminus_class.indirection = indirection }.should_not raise_error
-            @terminus_class.indirection.should equal(indirection)
-        end
-
-        it "should look up indirection instances when only a name has been provided" do
-            indirection = mock 'indirection'
-            Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns(indirection)
-            @terminus_class.indirection = :myind
-            @terminus_class.indirection.should equal(indirection)
-        end
-
-        it "should fail when provided a name that does not resolve to an indirection" do
-            Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns(nil)
-            proc { @terminus_class.indirection = :myind }.should raise_error(ArgumentError)
-
-            # It shouldn't overwrite our existing one (or, more normally, it shouldn't set
-            # anything).
-            @terminus_class.indirection.should equal(@indirection)
-        end
-    end
-
-    describe Puppet::Indirector::Terminus, " when creating terminus classes" do
-        it "should associate the subclass with an indirection based on the subclass constant" do
-            @terminus.indirection.should equal(@indirection)
-        end
-
-        it "should set the subclass's type to the abstract terminus name" do
-            @terminus.terminus_type.should == :abstract
-        end
-
-        it "should set the subclass's name to the indirection name" do
-            @terminus.name.should == :term_type
-        end
-
-        it "should set the subclass's model to the indirection model" do
-            @indirection.expects(:model).returns :yay
-            @terminus.model.should == :yay
-        end
-    end
-
-    describe Puppet::Indirector::Terminus, " when a terminus instance" do
-
-        it "should return the class's name as its name" do
-            @terminus.name.should == :term_type
-        end
-
-        it "should return the class's indirection as its indirection" do
-            @terminus.indirection.should equal(@indirection)
-        end
-
-        it "should set the instances's type to the abstract terminus type's name" do
-            @terminus.terminus_type.should == :abstract
-        end
-
-        it "should set the instances's model to the indirection's model" do
-            @indirection.expects(:model).returns :yay
-            @terminus.model.should == :yay
-        end
-    end
-end
-
-# LAK: This could reasonably be in the Indirection instances, too.  It doesn't make
-# a whole heckuva lot of difference, except that with the instance loading in
-# the Terminus base class, we have to have a check to see if we're already
-# instance-loading a given terminus class type.
-describe Puppet::Indirector::Terminus, " when managing terminus classes" do
-    it "should provide a method for registering terminus classes" do
-        Puppet::Indirector::Terminus.should respond_to(:register_terminus_class)
-    end
-
-    it "should provide a method for returning terminus classes by name and type" do
-        terminus = stub 'terminus_type', :name => :abstract, :indirection_name => :whatever
-        Puppet::Indirector::Terminus.register_terminus_class(terminus)
-        Puppet::Indirector::Terminus.terminus_class(:whatever, :abstract).should equal(terminus)
-    end
-
-    it "should set up autoloading for any terminus class types requested" do
-        Puppet::Indirector::Terminus.expects(:instance_load).with(:test2, "puppet/indirector/test2")
-        Puppet::Indirector::Terminus.terminus_class(:test2, :whatever)
-    end
-
-    it "should load terminus classes that are not found" do
-        # Set up instance loading; it would normally happen automatically
-        Puppet::Indirector::Terminus.instance_load :test1, "puppet/indirector/test1"
-
-        Puppet::Indirector::Terminus.instance_loader(:test1).expects(:load).with(:yay)
-        Puppet::Indirector::Terminus.terminus_class(:test1, :yay)
-    end
-
-    it "should fail when no indirection can be found" do
-        Puppet::Indirector::Indirection.expects(:instance).with(:my_indirection).returns(nil)
-
-        @abstract_terminus = Class.new(Puppet::Indirector::Terminus) do
-            def self.to_s
-                "Abstract"
-            end
-        end
-        proc {
-            @terminus = Class.new(@abstract_terminus) do
-                def self.to_s
-                    "MyIndirection::TestType"
-                end
-            end
-        }.should raise_error(ArgumentError)
-    end
-
-    it "should register the terminus class with the terminus base class" do
-        Puppet::Indirector::Terminus.expects(:register_terminus_class).with do |type|
-            type.indirection_name == :my_indirection and type.name == :test_terminus
-        end
-        @indirection = stub 'indirection', :name => :my_indirection, :register_terminus_type => nil
-        Puppet::Indirector::Indirection.expects(:instance).with(:my_indirection).returns(@indirection)
-
-        @abstract_terminus = Class.new(Puppet::Indirector::Terminus) do
-            def self.to_s
-                "Abstract"
-            end
-        end
-
-        @terminus = Class.new(@abstract_terminus) do
-            def self.to_s
-                "MyIndirection::TestTerminus"
-            end
-        end
-    end
-end
-
-describe Puppet::Indirector::Terminus, " when parsing class constants for indirection and terminus names" do
-    before do
-        @subclass = mock 'subclass'
-        @subclass.stubs(:to_s).returns("TestInd::OneTwo")
-        @subclass.stubs(:mark_as_abstract_terminus)
-        Puppet::Indirector::Terminus.stubs(:register_terminus_class)
-    end
-
-    it "should fail when anonymous classes are used" do
-        proc { Puppet::Indirector::Terminus.inherited(Class.new) }.should raise_error(Puppet::DevError)
-    end
-
-    it "should use the last term in the constant for the terminus class name" do
-        @subclass.expects(:name=).with(:one_two)
-        @subclass.stubs(:indirection=)
-        Puppet::Indirector::Terminus.inherited(@subclass)
-    end
-
-    it "should convert the terminus name to a downcased symbol" do
-        @subclass.expects(:name=).with(:one_two)
-        @subclass.stubs(:indirection=)
-        Puppet::Indirector::Terminus.inherited(@subclass)
-    end
-
-    it "should use the second to last term in the constant for the indirection name" do
-        @subclass.expects(:indirection=).with(:test_ind)
-        @subclass.stubs(:name=)
-        @subclass.stubs(:terminus_type=)
-        Puppet::Indirector::File.inherited(@subclass)
-    end
-
-    it "should convert the indirection name to a downcased symbol" do
-        @subclass.expects(:indirection=).with(:test_ind)
-        @subclass.stubs(:name=)
-        @subclass.stubs(:terminus_type=)
-        Puppet::Indirector::File.inherited(@subclass)
-    end
-
-    it "should convert camel case to lower case with underscores as word separators" do
-        @subclass.expects(:name=).with(:one_two)
-        @subclass.stubs(:indirection=)
-
-        Puppet::Indirector::Terminus.inherited(@subclass)
-    end
-end
-
-describe Puppet::Indirector::Terminus, " when creating terminus class types" do
-    before do
-        Puppet::Indirector::Terminus.stubs(:register_terminus_class)
-        @subclass = Class.new(Puppet::Indirector::Terminus) do
-            def self.to_s
-                "Puppet::Indirector::Terminus::MyTermType"
-            end
-        end
-    end
-
-    it "should set the name of the abstract subclass to be its class constant" do
-        @subclass.name.should equal(:my_term_type)
-    end
-
-    it "should mark abstract terminus types as such" do
-        @subclass.should be_abstract_terminus
-    end
-
-    it "should not allow instances of abstract subclasses to be created" do
-        proc { @subclass.new }.should raise_error(Puppet::DevError)
-    end
-end
-

data/spec/unit/indirector/yaml.rb

@@ -1,145 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require 'puppet/indirector/yaml'
-
-describe Puppet::Indirector::Yaml, " when choosing file location" do
-    before :each do
-        @indirection = stub 'indirection', :name => :my_yaml, :register_terminus_type => nil
-        Puppet::Indirector::Indirection.stubs(:instance).with(:my_yaml).returns(@indirection)
-        @store_class = Class.new(Puppet::Indirector::Yaml) do
-            def self.to_s
-                "MyYaml::MyType"
-            end
-        end
-        @store = @store_class.new
-
-        @subject = Object.new
-        @subject.metaclass.send(:attr_accessor, :name)
-        @subject.name = :me
-
-        @dir = "/what/ever"
-        Puppet.settings.stubs(:value).returns("fakesettingdata")
-        Puppet.settings.stubs(:value).with(:clientyamldir).returns(@dir)
-
-        @request = stub 'request', :key => :me, :instance => @subject
-    end
-
-    describe Puppet::Indirector::Yaml, " when choosing file location" do
-        it "should use the yamldir if the process name is 'puppetmasterd'" do
-            Puppet.settings.expects(:value).with(:name).returns "puppetmasterd"
-            Puppet.settings.expects(:value).with(:yamldir).returns "/main/yaml/dir"
-            @store.path(:me).should =~ %r{^/main/yaml/dir}
-        end
-
-        it "should use the client yamldir if the process name is not 'puppetmasterd'" do
-            Puppet.settings.expects(:value).with(:name).returns "cient"
-            Puppet.settings.expects(:value).with(:clientyamldir).returns "/client/yaml/dir"
-            @store.path(:me).should =~ %r{^/client/yaml/dir}
-        end
-
-        it "should store all files in a single file root set in the Puppet defaults" do
-            @store.path(:me).should =~ %r{^#{@dir}}
-        end
-
-        it "should use the terminus name for choosing the subdirectory" do
-            @store.path(:me).should =~ %r{^#{@dir}/my_yaml}
-        end
-
-        it "should use the object's name to determine the file name" do
-            @store.path(:me).should =~ %r{me.yaml$}
-        end
-    end
-
-    describe Puppet::Indirector::Yaml, " when storing objects as YAML" do
-        it "should only store objects that respond to :name" do
-            @request.stubs(:instance).returns Object.new
-            proc { @store.save(@request) }.should raise_error(ArgumentError)
-        end
-
-        it "should convert Ruby objects to YAML and write them to disk using a write lock" do
-            yaml = @subject.to_yaml
-            file = mock 'file'
-            path = @store.send(:path, @subject.name)
-            FileTest.expects(:exist?).with(File.dirname(path)).returns(true)
-            @store.expects(:writelock).with(path, 0660).yields(file)
-            file.expects(:print).with(yaml)
-
-            @store.save(@request)
-        end
-
-        it "should create the indirection subdirectory if it does not exist" do
-            yaml = @subject.to_yaml
-            file = mock 'file'
-            path = @store.send(:path, @subject.name)
-            dir = File.dirname(path)
-
-            FileTest.expects(:exist?).with(dir).returns(false)
-            Dir.expects(:mkdir).with(dir)
-
-            @store.expects(:writelock).yields(file)
-            file.expects(:print).with(yaml)
-
-            @store.save(@request)
-        end
-    end
-
-    describe Puppet::Indirector::Yaml, " when retrieving YAML" do
-        it "should read YAML in from disk using a read lock and convert it to Ruby objects" do
-            path = @store.send(:path, @subject.name)
-
-            yaml = @subject.to_yaml
-            FileTest.expects(:exist?).with(path).returns(true)
-
-            fh = mock 'filehandle'
-            @store.expects(:readlock).with(path).yields fh
-            fh.expects(:read).returns yaml
-
-            @store.find(@request).instance_variable_get("@name").should == :me
-        end
-
-        it "should fail coherently when the stored YAML is invalid" do
-            path = @store.send(:path, @subject.name)
-            FileTest.expects(:exist?).with(path).returns(true)
-
-            # Something that will fail in yaml
-            yaml = "--- !ruby/object:Hash"
-
-            fh = mock 'filehandle'
-            @store.expects(:readlock).yields fh
-            fh.expects(:read).returns yaml
-
-            proc { @store.find(@request) }.should raise_error(Puppet::Error)
-        end
-    end
-
-    describe Puppet::Indirector::Yaml, " when searching" do
-      it "should return an array of fact instances with one instance for each file when globbing *" do
-        @request = stub 'request', :key => "*", :instance => @subject
-        @one = mock 'one'
-        @two = mock 'two'
-        @store.expects(:base).returns "/my/yaml/dir"
-        Dir.expects(:glob).with(File.join("/my/yaml/dir", @store.class.indirection_name.to_s, @request.key)).returns(%w{one.yaml two.yaml})
-        YAML.expects(:load_file).with("one.yaml").returns @one;
-        YAML.expects(:load_file).with("two.yaml").returns @two;
-        @store.search(@request).should == [@one, @two]
-      end
-
-      it "should return an array containing a single instance of fact when globbing 'one*'" do
-        @request = stub 'request', :key => "one*", :instance => @subject
-        @one = mock 'one'
-        @store.expects(:base).returns "/my/yaml/dir"
-        Dir.expects(:glob).with(File.join("/my/yaml/dir", @store.class.indirection_name.to_s, @request.key)).returns(%w{one.yaml})
-        YAML.expects(:load_file).with("one.yaml").returns @one;
-        @store.search(@request).should == [@one]
-      end
-
-      it "should return an empty array when the glob doesn't match anything" do
-        @request = stub 'request', :key => "f*ilglobcanfail*", :instance => @subject
-        @store.expects(:base).returns "/my/yaml/dir"
-        Dir.expects(:glob).with(File.join("/my/yaml/dir", @store.class.indirection_name.to_s, @request.key)).returns([])
-        @store.search(@request).should == []
-      end
-    end
-end

data/spec/unit/module.rb

@@ -1,247 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe Puppet::Module do
-    before do
-        # This is necessary because of the extra checks we have for the deprecated
-        # 'plugins' directory
-        FileTest.stubs(:exist?).returns false
-    end
-
-    it "should have a class method that returns a named module from a given environment" do
-        env = mock 'module'
-        env.expects(:module).with("mymod").returns "yep"
-        Puppet::Node::Environment.expects(:new).with("myenv").returns env
-
-        Puppet::Module.find("mymod", "myenv").should == "yep"
-    end
-
-    it "should return nil if asked for a named module that doesn't exist" do
-        env = mock 'module'
-        env.expects(:module).with("mymod").returns nil
-        Puppet::Node::Environment.expects(:new).with("myenv").returns env
-
-        Puppet::Module.find("mymod", "myenv").should be_nil
-    end
-
-    it "should return nil if asked for a module whose name is 'nil'" do
-        Puppet::Module.find(nil, "myenv").should be_nil
-    end
-
-    it "should provide support for logging" do
-        Puppet::Module.ancestors.should be_include(Puppet::Util::Logging)
-    end
-
-    it "should be able to be converted to a string" do
-        Puppet::Module.new("foo").to_s.should == "Module foo"
-    end
-
-    it "should add the path to its string form if the module is found" do
-        mod = Puppet::Module.new("foo")
-        mod.stubs(:path).returns "/a"
-        mod.to_s.should == "Module foo(/a)"
-    end
-
-    it "should fail if its name is not alphanumeric" do
-        lambda { Puppet::Module.new(".something") }.should raise_error(Puppet::Module::InvalidName)
-    end
-
-    it "should require a name at initialization" do
-        lambda { Puppet::Module.new }.should raise_error(ArgumentError)
-    end
-
-    it "should convert an environment name into an Environment instance" do
-        Puppet::Module.new("foo", "prod").environment.should be_instance_of(Puppet::Node::Environment)
-    end
-
-    it "should accept an environment at initialization" do
-        Puppet::Module.new("foo", :prod).environment.name.should == :prod
-    end
-
-    it "should use the default environment if none is provided" do
-        env = Puppet::Node::Environment.new
-        Puppet::Module.new("foo").environment.should equal(env)
-    end
-
-    it "should use any provided Environment instance" do
-        env = Puppet::Node::Environment.new
-        Puppet::Module.new("foo", env).environment.should equal(env)
-    end
-
-    it "should return the path to the first found instance in its environment's module paths as its path" do
-        mod = Puppet::Module.new("foo")
-        env = mock 'environment'
-        mod.stubs(:environment).returns env
-
-        env.expects(:modulepath).returns %w{/a /b /c}
-
-        FileTest.expects(:exist?).with("/a/foo").returns false
-        FileTest.expects(:exist?).with("/b/foo").returns true
-        FileTest.expects(:exist?).with("/c/foo").never
-
-        mod.path.should == "/b/foo"
-    end
-
-    it "should be considered existent if it exists in at least one module path" do
-        mod = Puppet::Module.new("foo")
-        mod.expects(:path).returns "/a/foo"
-        mod.should be_exist
-    end
-
-    it "should be considered nonexistent if it does not exist in any of the module paths" do
-        mod = Puppet::Module.new("foo")
-        mod.expects(:path).returns nil
-        mod.should_not be_exist
-    end
-
-    [:plugins, :templates, :files, :manifests].each do |filetype|
-        dirname = filetype == :plugins ? "lib" : filetype.to_s
-        it "should be able to return individual #{filetype}" do
-            mod = Puppet::Module.new("foo")
-            mod.stubs(:path).returns "/a/foo"
-            path = File.join("/a/foo", dirname, "my/file")
-            FileTest.expects(:exist?).with(path).returns true
-            mod.send(filetype.to_s.sub(/s$/, ''), "my/file").should == path
-        end
-
-        it "should consider #{filetype} to be present if their base directory exists" do
-            mod = Puppet::Module.new("foo")
-            mod.stubs(:path).returns "/a/foo"
-            path = File.join("/a/foo", dirname)
-            FileTest.expects(:exist?).with(path).returns true
-            mod.send(filetype.to_s + "?").should be_true
-        end
-
-        it "should consider #{filetype} to be absent if their base directory does not exist" do
-            mod = Puppet::Module.new("foo")
-            mod.stubs(:path).returns "/a/foo"
-            path = File.join("/a/foo", dirname)
-            FileTest.expects(:exist?).with(path).returns false
-            mod.send(filetype.to_s + "?").should be_false
-        end
-
-        it "should consider #{filetype} to be absent if the module base directory does not exist" do
-            mod = Puppet::Module.new("foo")
-            mod.stubs(:path).returns nil
-            mod.send(filetype.to_s + "?").should be_false
-        end
-
-        it "should return nil if asked to return individual #{filetype} that don't exist" do
-            mod = Puppet::Module.new("foo")
-            mod.stubs(:path).returns "/a/foo"
-            path = File.join("/a/foo", dirname, "my/file")
-            FileTest.expects(:exist?).with(path).returns false
-            mod.send(filetype.to_s.sub(/s$/, ''), "my/file").should be_nil
-        end
-
-        it "should return nil when asked for individual #{filetype} if the module does not exist" do
-            mod = Puppet::Module.new("foo")
-            mod.stubs(:path).returns nil
-            mod.send(filetype.to_s.sub(/s$/, ''), "my/file").should be_nil
-        end
-
-        it "should return the base directory if asked for a nil path" do
-            mod = Puppet::Module.new("foo")
-            mod.stubs(:path).returns "/a/foo"
-            base = File.join("/a/foo", dirname)
-            FileTest.expects(:exist?).with(base).returns true
-            mod.send(filetype.to_s.sub(/s$/, ''), nil).should == base
-        end
-    end
-
-    %w{plugins files}.each do |filetype|
-        short = filetype.sub(/s$/, '')
-        dirname = filetype == "plugins" ? "lib" : filetype.to_s
-        it "should be able to return the #{short} directory" do
-            Puppet::Module.new("foo").should respond_to(short + "_directory")
-        end
-
-        it "should return the path to the #{short} directory" do
-            mod = Puppet::Module.new("foo")
-            mod.stubs(:path).returns "/a/foo"
-
-            mod.send(short + "_directory").should == "/a/foo/#{dirname}"
-        end
-    end
-
-    it "should throw a warning if plugins are in a 'plugins' directory rather than a 'lib' directory" do
-        mod = Puppet::Module.new("foo")
-        mod.stubs(:path).returns "/a/foo"
-        FileTest.expects(:exist?).with("/a/foo/plugins").returns true
-
-        mod.expects(:warning)
-
-        mod.plugin_directory.should == "/a/foo/plugins"
-    end
-
-    it "should default to 'lib' for the plugins directory" do
-        mod = Puppet::Module.new("foo")
-        mod.stubs(:path).returns "/a/foo"
-        mod.plugin_directory.should == "/a/foo/lib"
-    end
-end
-
-describe Puppet::Module, " when building its search path" do
-    it "should use the current environment's search path if no environment is specified" do
-        env = mock 'env'
-        env.expects(:modulepath).returns "eh"
-        Puppet::Node::Environment.expects(:new).with(nil).returns env
-
-        Puppet::Module.modulepath.should == "eh"
-    end
-
-    it "should use the specified environment's search path if an environment is specified" do
-        env = mock 'env'
-        env.expects(:modulepath).returns "eh"
-        Puppet::Node::Environment.expects(:new).with("foo").returns env
-
-        Puppet::Module.modulepath("foo").should == "eh"
-    end
-end
-
-describe Puppet::Module, "when finding matching manifests" do
-    before do
-        @mod = Puppet::Module.new("mymod")
-        @mod.stubs(:path).returns "/a"
-    end
-
-    it "should return all manifests matching the glob pattern" do
-        Dir.expects(:glob).with("/a/manifests/yay/*.pp").returns(%w{foo bar})
-
-        @mod.match_manifests("yay/*.pp").should == %w{foo bar}
-    end
-
-    it "should not return directories" do
-        Dir.expects(:glob).with("/a/manifests/yay/*.pp").returns(%w{foo bar})
-
-        FileTest.expects(:directory?).with("foo").returns false
-        FileTest.expects(:directory?).with("bar").returns true
-        @mod.match_manifests("yay/*.pp").should == %w{foo}
-    end
-
-    it "should default to the 'init.pp' file if no glob pattern is specified" do
-        FileTest.stubs(:exist?).returns true
-
-        @mod.match_manifests(nil).should == %w{/a/manifests/init.pp}
-    end
-
-    it "should return all manifests matching the glob pattern in all existing paths" do
-        Dir.expects(:glob).with("/a/manifests/yay/*.pp").returns(%w{a b})
-
-        @mod.match_manifests("yay/*.pp").should == %w{a b}
-    end
-
-    it "should match the glob pattern plus '.pp' if no results are found" do
-        Dir.expects(:glob).with("/a/manifests/yay/foo").returns([])
-        Dir.expects(:glob).with("/a/manifests/yay/foo.pp").returns(%w{yay})
-
-        @mod.match_manifests("yay/foo").should == %w{yay}
-    end
-
-    it "should return an empty array if no manifests matched" do
-        Dir.expects(:glob).with("/a/manifests/yay/*.pp").returns([])
-
-        @mod.match_manifests("yay/*.pp").should == []
-    end
-end