puppet 0.25.5 → 2.6.0

data/spec/unit/indirector/yaml_spec.rb

@@ -0,0 +1,146 @@
+#!/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.singleton_class.send(:attr_accessor, :name)
+    @subject.name = :me
+
+    @dir = "/what/ever"
+    Puppet.settings.stubs(:value).returns("fakesettingdata")
+    Puppet.settings.stubs(:value).with(:clientyamldir).returns(@dir)
+    Puppet.run_mode.stubs(:master?).returns false
+
+    @request = stub 'request', :key => :me, :instance => @subject
+  end
+
+  describe Puppet::Indirector::Yaml, " when choosing file location" do
+    it "should use the server_datadir if the run_mode is master" do
+      Puppet.run_mode.expects(:master?).returns true
+      Puppet.settings.expects(:value).with(:yamldir).returns "/server/yaml/dir"
+      @store.path(:me).should =~ %r{^/server/yaml/dir}
+    end
+
+    it "should use the client yamldir if the run_mode is not master" do
+      Puppet.run_mode.expects(:master?).returns false
+      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/indirector_spec.rb

@@ -0,0 +1,157 @@
+#!/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.singleton_class.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 an optional key to the indirection's :save method" do
+      @indirection.expects(:save).with("key", @instance)
+      @instance.save "key"
+    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/module_spec.rb

@@ -0,0 +1,547 @@
+#!/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 support a 'version' attribute" do
+    mod = Puppet::Module.new("mymod")
+    mod.version = 1.09
+    mod.version.should == 1.09
+  end
+
+  it "should support a 'source' attribute" do
+    mod = Puppet::Module.new("mymod")
+    mod.source = "http://foo/bar"
+    mod.source.should == "http://foo/bar"
+  end
+
+  it "should support a 'project_page' attribute" do
+    mod = Puppet::Module.new("mymod")
+    mod.project_page = "http://foo/bar"
+    mod.project_page.should == "http://foo/bar"
+  end
+
+  it "should support an 'author' attribute" do
+    mod = Puppet::Module.new("mymod")
+    mod.author = "Luke Kanies <luke@madstop.com>"
+    mod.author.should == "Luke Kanies <luke@madstop.com>"
+  end
+
+  it "should support a 'license' attribute" do
+    mod = Puppet::Module.new("mymod")
+    mod.license = "GPL2"
+    mod.license.should == "GPL2"
+  end
+
+  it "should support a 'summary' attribute" do
+    mod = Puppet::Module.new("mymod")
+    mod.summary = "GPL2"
+    mod.summary.should == "GPL2"
+  end
+
+  it "should support a 'description' attribute" do
+    mod = Puppet::Module.new("mymod")
+    mod.description = "GPL2"
+    mod.description.should == "GPL2"
+  end
+
+  it "should support specifying a compatible puppet version" do
+    mod = Puppet::Module.new("mymod")
+    mod.puppetversion = "0.25"
+    mod.puppetversion.should == "0.25"
+  end
+
+  it "should validate that the puppet version is compatible" do
+    mod = Puppet::Module.new("mymod")
+    mod.puppetversion = "0.25"
+    Puppet.expects(:version).returns "0.25"
+    mod.validate_puppet_version
+  end
+
+  it "should fail if the specified puppet version is not compatible" do
+    mod = Puppet::Module.new("mymod")
+    mod.puppetversion = "0.25"
+    Puppet.stubs(:version).returns "0.24"
+    lambda { mod.validate_puppet_version }.should raise_error(Puppet::Module::IncompatibleModule)
+  end
+
+  describe "when specifying required modules" do
+    it "should support specifying a required module" do
+      mod = Puppet::Module.new("mymod")
+      mod.requires "foobar"
+    end
+
+    it "should support specifying multiple required modules" do
+      mod = Puppet::Module.new("mymod")
+      mod.requires "foobar"
+      mod.requires "baz"
+    end
+
+    it "should support specifying a required module and version" do
+      mod = Puppet::Module.new("mymod")
+      mod.requires "foobar", 1.0
+    end
+
+    it "should fail when required modules are missing" do
+      mod = Puppet::Module.new("mymod")
+      mod.requires "foobar"
+
+      mod.environment.expects(:module).with("foobar").returns nil
+
+      lambda { mod.validate_dependencies }.should raise_error(Puppet::Module::MissingModule)
+    end
+
+    it "should fail when required modules are present but of the wrong version" do
+      mod = Puppet::Module.new("mymod")
+      mod.requires "foobar", 1.0
+
+      foobar = Puppet::Module.new("foobar")
+      foobar.version = 2.0
+
+      mod.environment.expects(:module).with("foobar").returns foobar
+
+      lambda { mod.validate_dependencies }.should raise_error(Puppet::Module::IncompatibleModule)
+    end
+
+    it "should have valid dependencies when no dependencies have been specified" do
+      mod = Puppet::Module.new("mymod")
+
+      lambda { mod.validate_dependencies }.should_not raise_error
+    end
+
+    it "should fail when some dependencies are present but others aren't" do
+      mod = Puppet::Module.new("mymod")
+      mod.requires "foobar"
+      mod.requires "baz"
+
+      mod.environment.expects(:module).with("foobar").returns Puppet::Module.new("foobar")
+      mod.environment.expects(:module).with("baz").returns nil
+
+      lambda { mod.validate_dependencies }.should raise_error(Puppet::Module::MissingModule)
+    end
+
+    it "should have valid dependencies when all dependencies are met" do
+      mod = Puppet::Module.new("mymod")
+      mod.requires "foobar", 1.0
+      mod.requires "baz"
+
+      foobar = Puppet::Module.new("foobar")
+      foobar.version = 1.0
+
+      baz = Puppet::Module.new("baz")
+
+      mod.environment.expects(:module).with("foobar").returns foobar
+      mod.environment.expects(:module).with("baz").returns baz
+
+      lambda { mod.validate_dependencies }.should_not raise_error
+    end
+
+    it "should validate its dependendencies on initialization" do
+      Puppet::Module.any_instance.expects(:validate_dependencies)
+      Puppet::Module.new("mymod")
+    end
+  end
+
+  describe "when managing supported platforms" do
+    it "should support specifying a supported platform" do
+      mod = Puppet::Module.new("mymod")
+      mod.supports "solaris"
+    end
+
+    it "should support specifying a supported platform and version" do
+      mod = Puppet::Module.new("mymod")
+      mod.supports "solaris", 1.0
+    end
+
+    it "should fail when not running on a supported platform" do
+      pending "Not sure how to send client platform to the module"
+      mod = Puppet::Module.new("mymod")
+      Facter.expects(:value).with("operatingsystem").returns "Solaris"
+
+      mod.supports "hpux"
+
+      lambda { mod.validate_supported_platform }.should raise_error(Puppet::Module::UnsupportedPlatform)
+    end
+
+    it "should fail when supported platforms are present but of the wrong version" do
+      pending "Not sure how to send client platform to the module"
+      mod = Puppet::Module.new("mymod")
+      Facter.expects(:value).with("operatingsystem").returns "Solaris"
+      Facter.expects(:value).with("operatingsystemrelease").returns 2.0
+
+      mod.supports "Solaris", 1.0
+
+      lambda { mod.validate_supported_platform }.should raise_error(Puppet::Module::IncompatiblePlatform)
+    end
+
+    it "should be considered supported when no supported platforms have been specified" do
+      pending "Not sure how to send client platform to the module"
+      mod = Puppet::Module.new("mymod")
+      lambda { mod.validate_supported_platform }.should_not raise_error
+    end
+
+    it "should be considered supported when running on a supported platform" do
+      pending "Not sure how to send client platform to the module"
+      mod = Puppet::Module.new("mymod")
+      Facter.expects(:value).with("operatingsystem").returns "Solaris"
+      Facter.expects(:value).with("operatingsystemrelease").returns 2.0
+
+      mod.supports "Solaris", 1.0
+
+      lambda { mod.validate_supported_platform }.should raise_error(Puppet::Module::IncompatiblePlatform)
+    end
+
+    it "should be considered supported when running on any of multiple supported platforms" do
+      pending "Not sure how to send client platform to the module"
+    end
+
+    it "should validate its platform support on initialization" do
+      pending "Not sure how to send client platform to the module"
+    end
+  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"
+    @pq_glob_with_extension = "yay/*.xx"
+    @fq_glob_with_extension = "/a/manifests/#{@pq_glob_with_extension}"
+  end
+
+  it "should return all manifests matching the glob pattern" do
+    Dir.expects(:glob).with(@fq_glob_with_extension).returns(%w{foo bar})
+    FileTest.stubs(:directory?).returns false
+
+    @mod.match_manifests(@pq_glob_with_extension).should == %w{foo bar}
+  end
+
+  it "should not return directories" do
+    Dir.expects(:glob).with(@fq_glob_with_extension).returns(%w{foo bar})
+
+    FileTest.expects(:directory?).with("foo").returns false
+    FileTest.expects(:directory?).with("bar").returns true
+    @mod.match_manifests(@pq_glob_with_extension).should == %w{foo}
+  end
+
+  it "should default to the 'init' file if no glob pattern is specified" do
+    Dir.expects(:glob).with("/a/manifests/init.{pp,rb}").returns(%w{/a/manifests/init.pp})
+
+    @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(@fq_glob_with_extension).returns(%w{a b})
+
+    @mod.match_manifests(@pq_glob_with_extension).should == %w{a b}
+  end
+
+  it "should match the glob pattern plus '.{pp,rb}' if no extention is specified" do
+    Dir.expects(:glob).with("/a/manifests/yay/foo.{pp,rb}").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(@fq_glob_with_extension).returns([])
+
+    @mod.match_manifests(@pq_glob_with_extension).should == []
+  end
+end
+
+describe Puppet::Module do
+  before do
+    Puppet::Module.any_instance.stubs(:path).returns "/my/mod/path"
+    @module = Puppet::Module.new("foo")
+  end
+
+  it "should use 'License' in its current path as its metadata file" do
+    @module.license_file.should == "/my/mod/path/License"
+  end
+
+  it "should return nil as its license file when the module has no path" do
+    Puppet::Module.any_instance.stubs(:path).returns nil
+    Puppet::Module.new("foo").license_file.should be_nil
+  end
+
+  it "should cache the license file" do
+    Puppet::Module.any_instance.expects(:path).once.returns nil
+    mod = Puppet::Module.new("foo")
+    mod.license_file.should == mod.license_file
+  end
+
+  it "should use 'metadata.json' in its current path as its metadata file" do
+    @module.metadata_file.should == "/my/mod/path/metadata.json"
+  end
+
+  it "should return nil as its metadata file when the module has no path" do
+    Puppet::Module.any_instance.stubs(:path).returns nil
+    Puppet::Module.new("foo").metadata_file.should be_nil
+  end
+
+  it "should cache the metadata file" do
+    Puppet::Module.any_instance.expects(:path).once.returns nil
+    mod = Puppet::Module.new("foo")
+    mod.metadata_file.should == mod.metadata_file
+  end
+
+  it "should know if it has a metadata file" do
+    FileTest.expects(:exist?).with(@module.metadata_file).returns true
+
+    @module.should be_has_metadata
+  end
+
+  it "should know if it is missing a metadata file" do
+    FileTest.expects(:exist?).with(@module.metadata_file).returns false
+
+    @module.should_not be_has_metadata
+  end
+
+  it "should be able to parse its metadata file" do
+    @module.should respond_to(:load_metadata)
+  end
+
+  it "should parse its metadata file on initialization if it is present" do
+    Puppet::Module.any_instance.expects(:has_metadata?).returns true
+    Puppet::Module.any_instance.expects(:load_metadata)
+
+    Puppet::Module.new("yay")
+  end
+
+  describe "when loading the medatada file" do
+    confine "Cannot test module metadata without json" => Puppet.features.json?
+
+    before do
+      @data = {
+        :license => "GPL2",
+        :author => "luke",
+        :version => "1.0",
+        :source => "http://foo/",
+        :puppetversion => "0.25"
+      }
+      @text = @data.to_json
+
+      @module = Puppet::Module.new("foo")
+      @module.stubs(:metadata_file).returns "/my/file"
+      File.stubs(:read).with("/my/file").returns @text
+    end
+
+    %w{source author version license}.each do |attr|
+      it "should set #{attr} if present in the metadata file" do
+        @module.load_metadata
+        @module.send(attr).should == @data[attr.to_sym]
+      end
+
+      it "should fail if #{attr} is not present in the metadata file" do
+        @data.delete(attr.to_sym)
+        @text = @data.to_json
+        File.stubs(:read).with("/my/file").returns @text
+        lambda { @module.load_metadata }.should raise_error(Puppet::Module::MissingMetadata)
+      end
+    end
+
+    it "should set puppetversion if present in the metadata file" do
+      @module.load_metadata
+      @module.puppetversion.should == @data[:puppetversion]
+    end
+
+
+    it "should fail if the discovered name is different than the metadata name"
+  end
+end