diff --git a/lib/puppet/module.rb b/lib/puppet/module.rb
index 094609f16..21a5d1fe6 100644
--- a/lib/puppet/module.rb
+++ b/lib/puppet/module.rb
@@ -1,327 +1,328 @@
 require 'puppet/util/logging'
 require 'semver'
 require 'json'
 
 # Support for modules
 class Puppet::Module
   class Error < Puppet::Error; end
   class MissingModule < Error; end
   class IncompatibleModule < Error; end
   class UnsupportedPlatform < Error; end
   class IncompatiblePlatform < Error; end
   class MissingMetadata < Error; end
   class InvalidName < Error; end
   class InvalidFilePattern < Error; end
 
   include Puppet::Util::Logging
 
   FILETYPES = {
     "manifests" => "manifests",
     "files" => "files",
     "templates" => "templates",
     "plugins" => "lib",
     "pluginfacts" => "facts.d",
   }
 
   # Find and return the +module+ that +path+ belongs to. If +path+ is
   # absolute, or if there is no module whose name is the first component
   # of +path+, return +nil+
   def self.find(modname, environment = nil)
     return nil unless modname
     # Unless a specific environment is given, use the current environment
     env = environment ? Puppet.lookup(:environments).get!(environment) : Puppet.lookup(:current_environment)
     env.module(modname)
   end
 
   attr_reader :name, :environment, :path, :metadata
   attr_writer :environment
 
   attr_accessor :dependencies, :forge_name
   attr_accessor :source, :author, :version, :license, :puppetversion, :summary, :description, :project_page
 
   def initialize(name, path, environment)
     @name = name
     @path = path
     @environment = environment
 
     assert_validity
 
     load_metadata if has_metadata?
 
     validate_puppet_version
 
     @absolute_path_to_manifests = Puppet::FileSystem::PathPattern.absolute(manifests)
   end
 
   def has_metadata?
     return false unless metadata_file
 
     return false unless Puppet::FileSystem.exist?(metadata_file)
 
     begin
       metadata =  JSON.parse(File.read(metadata_file))
     rescue JSON::JSONError => e
       Puppet.debug("#{name} has an invalid and unparsable metadata.json file.  The parse error: #{e.message}")
       return false
     end
 
     return metadata.is_a?(Hash) && !metadata.keys.empty?
   end
 
   FILETYPES.each do |type, location|
     # A boolean method to let external callers determine if
     # we have files of a given type.
     define_method(type +'?') do
       type_subpath = subpath(location)
       unless Puppet::FileSystem.exist?(type_subpath)
         Puppet.debug("No #{type} found in subpath '#{type_subpath}' " +
                          "(file / directory does not exist)")
         return false
       end
 
       return true
     end
 
     # A method for returning a given file of a given type.
     # e.g., file = mod.manifest("my/manifest.pp")
     #
     # If the file name is nil, then the base directory for the
     # file type is passed; this is used for fileserving.
     define_method(type.sub(/s$/, '')) do |file|
       # If 'file' is nil then they're asking for the base path.
       # This is used for things like fileserving.
       if file
         full_path = File.join(subpath(location), file)
       else
         full_path = subpath(location)
       end
 
       return nil unless Puppet::FileSystem.exist?(full_path)
       return full_path
     end
 
     # Return the base directory for the given type
     define_method(type) do
       subpath(location)
     end
   end
 
   def license_file
     return @license_file if defined?(@license_file)
 
     return @license_file = nil unless path
     @license_file = File.join(path, "License")
   end
 
   def load_metadata
     @metadata = data = JSON.parse(File.read(metadata_file))
     @forge_name = data['name'].gsub('-', '/') if data['name']
 
     [:source, :author, :version, :license, :puppetversion, :dependencies].each do |attr|
       unless value = data[attr.to_s]
         unless attr == :puppetversion
           raise MissingMetadata, "No #{attr} module metadata provided for #{self.name}"
         end
       end
 
       # NOTICE: The fallback to `versionRequirement` is something we'd like to
       # not have to support, but we have a reasonable number of releases that
       # don't use `version_requirement`. When we can deprecate this, we should.
       if attr == :dependencies
         value.each do |dep|
           dep['version_requirement'] ||= dep['versionRequirement'] || '>= 0.0.0'
         end
       end
 
       send(attr.to_s + "=", value)
     end
   end
 
   # Return the list of manifests matching the given glob pattern,
   # defaulting to 'init.pp' for empty modules.
   def match_manifests(rest)
     if rest
       wanted_manifests = wanted_manifests_from(rest)
       searched_manifests = wanted_manifests.glob.reject { |f| FileTest.directory?(f) }
     else
       searched_manifests = []
     end
 
     # (#4220) Always ensure init.pp in case class is defined there.
     init_manifest = manifest("init.pp")
     if !init_manifest.nil? && !searched_manifests.include?(init_manifest)
       searched_manifests.unshift(init_manifest)
     end
     searched_manifests
   end
 
   def all_manifests
     return [] unless Puppet::FileSystem.exist?(manifests)
 
     Dir.glob(File.join(manifests, '**', '*.pp'))
   end
 
   def metadata_file
     return @metadata_file if defined?(@metadata_file)
 
     return @metadata_file = nil unless path
     @metadata_file = File.join(path, "metadata.json")
   end
 
   def modulepath
     File.dirname(path) if path
   end
 
   # Find all plugin directories.  This is used by the Plugins fileserving mount.
   def plugin_directory
     subpath("lib")
   end
 
   def plugin_fact_directory
     subpath("facts.d")
   end
 
   def has_external_facts?
     File.directory?(plugin_fact_directory)
   end
 
   def supports(name, version = nil)
     @supports ||= []
     @supports << [name, version]
   end
 
   def to_s
     result = "Module #{name}"
     result += "(#{path})" if path
     result
   end
 
   def dependencies_as_modules
     dependent_modules = []
     dependencies and dependencies.each do |dep|
       author, dep_name = dep["name"].split('/')
       found_module = environment.module(dep_name)
       dependent_modules << found_module if found_module
     end
 
     dependent_modules
   end
 
   def required_by
     environment.module_requirements[self.forge_name] || {}
   end
 
   # Identify and mark unmet dependencies.  A dependency will be marked unmet
   # for the following reasons:
   #
   #   * not installed and is thus considered missing
   #   * installed and does not meet the version requirements for this module
   #   * installed and doesn't use semantic versioning
   #
   # Returns a list of hashes representing the details of an unmet dependency.
   #
   # Example:
   #
   #   [
   #     {
   #       :reason => :missing,
   #       :name   => 'puppetlabs-mysql',
   #       :version_constraint => 'v0.0.1',
   #       :mod_details => {
   #         :installed_version => '0.0.1'
   #       }
   #       :parent => {
   #         :name    => 'puppetlabs-bacula',
   #         :version => 'v1.0.0'
   #       }
   #     }
   #   ]
   #
   def unmet_dependencies
     unmet_dependencies = []
     return unmet_dependencies unless dependencies
 
     dependencies.each do |dependency|
-      forge_name = dependency['name']
+      name = dependency['name']
+      forge_name = name.tr('-', '/')
       version_string = dependency['version_requirement'] || '>= 0.0.0'
 
       dep_mod = begin
         environment.module_by_forge_name(forge_name)
       rescue
         nil
       end
 
       error_details = {
-        :name => forge_name,
+        :name => name,
         :version_constraint => version_string.gsub(/^(?=\d)/, "v"),
         :parent => {
           :name => self.forge_name,
           :version => self.version.gsub(/^(?=\d)/, "v")
         },
         :mod_details => {
           :installed_version => dep_mod.nil? ? nil : dep_mod.version
         }
       }
 
       unless dep_mod
         error_details[:reason] = :missing
         unmet_dependencies << error_details
         next
       end
 
       if version_string
         begin
           required_version_semver_range = SemVer[version_string]
           actual_version_semver = SemVer.new(dep_mod.version)
         rescue ArgumentError
           error_details[:reason] = :non_semantic_version
           unmet_dependencies << error_details
           next
         end
 
         unless required_version_semver_range.include? actual_version_semver
           error_details[:reason] = :version_mismatch
           unmet_dependencies << error_details
           next
         end
       end
     end
 
     unmet_dependencies
   end
 
   def validate_puppet_version
     return unless puppetversion and puppetversion != Puppet.version
     raise IncompatibleModule, "Module #{self.name} is only compatible with Puppet version #{puppetversion}, not #{Puppet.version}"
   end
 
   def ==(other)
     self.name == other.name &&
     self.version == other.version &&
     self.path == other.path &&
     self.environment == other.environment
   end
 
   private
 
   def wanted_manifests_from(pattern)
     begin
       extended = File.extname(pattern).empty? ? "#{pattern}.pp" : pattern
       relative_pattern = Puppet::FileSystem::PathPattern.relative(extended)
     rescue Puppet::FileSystem::PathPattern::InvalidPattern => error
       raise Puppet::Module::InvalidFilePattern.new(
         "The pattern \"#{pattern}\" to find manifests in the module \"#{name}\" " +
         "is invalid and potentially unsafe.", error)
     end
 
     relative_pattern.prefix_with(@absolute_path_to_manifests)
   end
 
   def subpath(type)
     File.join(path, type)
   end
 
   def assert_validity
     raise InvalidName, "Invalid module name #{name}; module names must be alphanumeric (plus '-'), not '#{name}'" unless name =~ /^[-\w]+$/
   end
 end
diff --git a/spec/unit/module_spec.rb b/spec/unit/module_spec.rb
index 0574f5bb2..4aa482f55 100755
--- a/spec/unit/module_spec.rb
+++ b/spec/unit/module_spec.rb
@@ -1,718 +1,745 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/files'
 require 'puppet_spec/modules'
 require 'puppet/module_tool/checksums'
 
 describe Puppet::Module do
   include PuppetSpec::Files
 
   let(:env) { mock("environment") }
   let(:path) { "/path" }
   let(:name) { "mymod" }
   let(:mod) { Puppet::Module.new(name, path, env) }
 
   before do
     # This is necessary because of the extra checks we have for the deprecated
     # 'plugins' directory
     Puppet::FileSystem.stubs(:exist?).returns false
   end
 
   it "should have a class method that returns a named module from a given environment" do
     env = Puppet::Node::Environment.create(:myenv, [])
     env.expects(:module).with(name).returns "yep"
     Puppet.override(:environments => Puppet::Environments::Static.new(env)) do
       expect(Puppet::Module.find(name, "myenv")).to eq("yep")
     end
   end
 
   it "should return nil if asked for a named module that doesn't exist" do
     env = Puppet::Node::Environment.create(:myenv, [])
     env.expects(:module).with(name).returns nil
     Puppet.override(:environments => Puppet::Environments::Static.new(env)) do
       expect(Puppet::Module.find(name, "myenv")).to be_nil
     end
   end
 
   describe "attributes" do
     it "should support a 'version' attribute" do
       mod.version = 1.09
       expect(mod.version).to eq(1.09)
     end
 
     it "should support a 'source' attribute" do
       mod.source = "http://foo/bar"
       expect(mod.source).to eq("http://foo/bar")
     end
 
     it "should support a 'project_page' attribute" do
       mod.project_page = "http://foo/bar"
       expect(mod.project_page).to eq("http://foo/bar")
     end
 
     it "should support an 'author' attribute" do
       mod.author = "Luke Kanies <luke@madstop.com>"
       expect(mod.author).to eq("Luke Kanies <luke@madstop.com>")
     end
 
     it "should support a 'license' attribute" do
       mod.license = "GPL2"
       expect(mod.license).to eq("GPL2")
     end
 
     it "should support a 'summary' attribute" do
       mod.summary = "GPL2"
       expect(mod.summary).to eq("GPL2")
     end
 
     it "should support a 'description' attribute" do
       mod.description = "GPL2"
       expect(mod.description).to eq("GPL2")
     end
 
     it "should support specifying a compatible puppet version" do
       mod.puppetversion = "0.25"
       expect(mod.puppetversion).to eq("0.25")
     end
   end
 
   it "should validate that the puppet version is compatible" do
     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.puppetversion = "0.25"
     Puppet.stubs(:version).returns "0.24"
     expect { mod.validate_puppet_version }.to raise_error(Puppet::Module::IncompatibleModule)
   end
 
   describe "when finding unmet dependencies" do
     before do
       Puppet::FileSystem.unstub(:exist?)
       @modpath = tmpdir('modpath')
       Puppet.settings[:modulepath] = @modpath
     end
 
+    it "should resolve module dependencies using forge names" do
+      parent = PuppetSpec::Modules.create(
+        'parent',
+        @modpath,
+        :metadata => {
+          :author => 'foo',
+          :dependencies => [{
+            "name" => "foo/child"
+          }]
+        },
+        :environment => env
+      )
+      child = PuppetSpec::Modules.create(
+        'child',
+        @modpath,
+        :metadata => {
+          :author => 'foo',
+          :dependencies => []
+        },
+        :environment => env
+      )
+
+      env.expects(:module_by_forge_name).with('foo/child').returns(child)
+
+      expect(parent.unmet_dependencies).to eq([])
+    end
+
     it "should list modules that are missing" do
       metadata_file = "#{@modpath}/needy/metadata.json"
       Puppet::FileSystem.expects(:exist?).with(metadata_file).returns true
       mod = PuppetSpec::Modules.create(
         'needy',
         @modpath,
         :metadata => {
           :dependencies => [{
             "version_requirement" => ">= 2.2.0",
             "name" => "baz/foobar"
           }]
         }
       )
       expect(mod.unmet_dependencies).to eq([{
         :reason => :missing,
         :name   => "baz/foobar",
         :version_constraint => ">= 2.2.0",
         :parent => { :name => 'puppetlabs/needy', :version => 'v9.9.9' },
         :mod_details => { :installed_version => nil }
       }])
     end
 
     it "should list modules that are missing and have invalid names" do
       metadata_file = "#{@modpath}/needy/metadata.json"
       Puppet::FileSystem.expects(:exist?).with(metadata_file).returns true
       mod = PuppetSpec::Modules.create(
         'needy',
         @modpath,
         :metadata => {
           :dependencies => [{
             "version_requirement" => ">= 2.2.0",
             "name" => "baz/foobar=bar"
           }]
         }
       )
       expect(mod.unmet_dependencies).to eq([{
         :reason => :missing,
         :name   => "baz/foobar=bar",
         :version_constraint => ">= 2.2.0",
         :parent => { :name => 'puppetlabs/needy', :version => 'v9.9.9' },
         :mod_details => { :installed_version => nil }
       }])
     end
 
     it "should list modules with unmet version requirement" do
       env = Puppet::Node::Environment.create(:testing, [@modpath])
 
       ['test_gte_req', 'test_specific_req', 'foobar'].each do |mod_name|
         metadata_file = "#{@modpath}/#{mod_name}/metadata.json"
         Puppet::FileSystem.stubs(:exist?).with(metadata_file).returns true
       end
       mod = PuppetSpec::Modules.create(
         'test_gte_req',
         @modpath,
         :metadata => {
           :dependencies => [{
             "version_requirement" => ">= 2.2.0",
             "name" => "baz/foobar"
           }]
         },
         :environment => env
       )
       mod2 = PuppetSpec::Modules.create(
         'test_specific_req',
         @modpath,
         :metadata => {
           :dependencies => [{
             "version_requirement" => "1.0.0",
             "name" => "baz/foobar"
           }]
         },
         :environment => env
       )
 
       PuppetSpec::Modules.create(
         'foobar',
         @modpath,
         :metadata => { :version => '2.0.0', :author  => 'baz' },
         :environment => env
       )
 
       expect(mod.unmet_dependencies).to eq([{
         :reason => :version_mismatch,
         :name   => "baz/foobar",
         :version_constraint => ">= 2.2.0",
         :parent => { :version => "v9.9.9", :name => "puppetlabs/test_gte_req" },
         :mod_details => { :installed_version => "2.0.0" }
       }])
 
       expect(mod2.unmet_dependencies).to eq([{
         :reason => :version_mismatch,
         :name   => "baz/foobar",
         :version_constraint => "v1.0.0",
         :parent => { :version => "v9.9.9", :name => "puppetlabs/test_specific_req" },
         :mod_details => { :installed_version => "2.0.0" }
       }])
 
     end
 
     it "should consider a dependency without a version requirement to be satisfied" do
       env = Puppet::Node::Environment.create(:testing, [@modpath])
 
       mod = PuppetSpec::Modules.create(
         'foobar',
         @modpath,
         :metadata => {
           :dependencies => [{
             "name" => "baz/foobar"
           }]
         },
         :environment => env
       )
       PuppetSpec::Modules.create(
         'foobar',
         @modpath,
         :metadata => {
           :version => '2.0.0',
           :author  => 'baz'
         },
         :environment => env
       )
 
       expect(mod.unmet_dependencies).to be_empty
     end
 
     it "should consider a dependency without a semantic version to be unmet" do
       env = Puppet::Node::Environment.create(:testing, [@modpath])
 
       metadata_file = "#{@modpath}/foobar/metadata.json"
       Puppet::FileSystem.expects(:exist?).with(metadata_file).times(3).returns true
       mod = PuppetSpec::Modules.create(
         'foobar',
         @modpath,
         :metadata => {
           :dependencies => [{
             "name" => "baz/foobar"
           }]
         },
         :environment => env
       )
       PuppetSpec::Modules.create(
         'foobar',
         @modpath,
         :metadata => {
           :version => '5.1',
           :author  => 'baz'
         },
         :environment => env
       )
 
       expect(mod.unmet_dependencies).to eq([{
         :reason => :non_semantic_version,
         :parent => { :version => "v9.9.9", :name => "puppetlabs/foobar" },
         :mod_details => { :installed_version => "5.1" },
         :name => "baz/foobar",
         :version_constraint => ">= 0.0.0"
       }])
     end
 
     it "should have valid dependencies when no dependencies have been specified" do
       mod = PuppetSpec::Modules.create(
         'foobar',
         @modpath,
         :metadata => {
           :dependencies => []
         }
       )
 
       expect(mod.unmet_dependencies).to eq([])
     end
 
     it "should only list unmet dependencies" do
       env = Puppet::Node::Environment.create(:testing, [@modpath])
 
       [name, 'satisfied'].each do |mod_name|
         metadata_file = "#{@modpath}/#{mod_name}/metadata.json"
         Puppet::FileSystem.expects(:exist?).with(metadata_file).twice.returns true
       end
       mod = PuppetSpec::Modules.create(
         name,
         @modpath,
         :metadata => {
           :dependencies => [
             {
               "version_requirement" => ">= 2.2.0",
               "name" => "baz/satisfied"
             },
             {
               "version_requirement" => ">= 2.2.0",
               "name" => "baz/notsatisfied"
             }
           ]
         },
         :environment => env
       )
       PuppetSpec::Modules.create(
         'satisfied',
         @modpath,
         :metadata => {
           :version => '3.3.0',
           :author  => 'baz'
         },
         :environment => env
       )
 
       expect(mod.unmet_dependencies).to eq([{
         :reason => :missing,
         :mod_details => { :installed_version => nil },
         :parent => { :version => "v9.9.9", :name => "puppetlabs/#{name}" },
         :name => "baz/notsatisfied",
         :version_constraint => ">= 2.2.0"
       }])
     end
 
     it "should be empty when all dependencies are met" do
       env = Puppet::Node::Environment.create(:testing, [@modpath])
 
       mod = PuppetSpec::Modules.create(
         'mymod2',
         @modpath,
         :metadata => {
           :dependencies => [
             {
               "version_requirement" => ">= 2.2.0",
               "name" => "baz/satisfied"
             },
             {
               "version_requirement" => "< 2.2.0",
               "name" => "baz/alsosatisfied"
             }
           ]
         },
         :environment => env
       )
       PuppetSpec::Modules.create(
         'satisfied',
         @modpath,
         :metadata => {
           :version => '3.3.0',
           :author  => 'baz'
         },
         :environment => env
       )
       PuppetSpec::Modules.create(
         'alsosatisfied',
         @modpath,
         :metadata => {
           :version => '2.1.0',
           :author  => 'baz'
         },
         :environment => env
       )
 
       expect(mod.unmet_dependencies).to be_empty
     end
   end
 
   describe "when managing supported platforms" do
     it "should support specifying a supported platform" do
       mod.supports "solaris"
     end
 
     it "should support specifying a supported platform and version" do
       mod.supports "solaris", 1.0
     end
   end
 
   it "should return nil if asked for a module whose name is 'nil'" do
     expect(Puppet::Module.find(nil, "myenv")).to be_nil
   end
 
   it "should provide support for logging" do
     expect(Puppet::Module.ancestors).to be_include(Puppet::Util::Logging)
   end
 
   it "should be able to be converted to a string" do
     expect(mod.to_s).to eq("Module #{name}(#{path})")
   end
 
   it "should fail if its name is not alphanumeric" do
     expect { Puppet::Module.new(".something", "/path", env) }.to raise_error(Puppet::Module::InvalidName)
   end
 
   it "should require a name at initialization" do
     expect { Puppet::Module.new }.to raise_error(ArgumentError)
   end
 
   it "should accept an environment at initialization" do
     expect(Puppet::Module.new("foo", "/path", env).environment).to eq(env)
   end
 
   describe '#modulepath' do
     it "should return the directory the module is installed in, if a path exists" do
       mod = Puppet::Module.new("foo", "/a/foo", env)
       expect(mod.modulepath).to eq('/a')
     end
   end
 
   [:plugins, :pluginfacts, :templates, :files, :manifests].each do |filetype|
     case filetype
       when :plugins
         dirname = "lib"
       when :pluginfacts
         dirname = "facts.d"
       else
         dirname = filetype.to_s
     end
     it "should be able to return individual #{filetype}" do
       module_file = File.join(path, dirname, "my/file")
       Puppet::FileSystem.expects(:exist?).with(module_file).returns true
       expect(mod.send(filetype.to_s.sub(/s$/, ''), "my/file")).to eq(module_file)
     end
 
     it "should consider #{filetype} to be present if their base directory exists" do
       module_file = File.join(path, dirname)
       Puppet::FileSystem.expects(:exist?).with(module_file).returns true
       expect(mod.send(filetype.to_s + "?")).to be_truthy
     end
 
     it "should consider #{filetype} to be absent if their base directory does not exist" do
       module_file = File.join(path, dirname)
       Puppet::FileSystem.expects(:exist?).with(module_file).returns false
       expect(mod.send(filetype.to_s + "?")).to be_falsey
     end
 
     it "should return nil if asked to return individual #{filetype} that don't exist" do
       module_file = File.join(path, dirname, "my/file")
       Puppet::FileSystem.expects(:exist?).with(module_file).returns false
       expect(mod.send(filetype.to_s.sub(/s$/, ''), "my/file")).to be_nil
     end
 
     it "should return the base directory if asked for a nil path" do
       base = File.join(path, dirname)
       Puppet::FileSystem.expects(:exist?).with(base).returns true
       expect(mod.send(filetype.to_s.sub(/s$/, ''), nil)).to eq(base)
     end
   end
 
   it "should return the path to the plugin directory" do
     expect(mod.plugin_directory).to eq(File.join(path, "lib"))
   end
 end
 
 describe Puppet::Module, "when finding matching manifests" do
   before do
     @mod = Puppet::Module.new("mymod", "/a", mock("environment"))
     @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
 
     expect(@mod.match_manifests(@pq_glob_with_extension)).to eq(%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
     expect(@mod.match_manifests(@pq_glob_with_extension)).to eq(%w{foo})
   end
 
   it "should default to the 'init' file if no glob pattern is specified" do
     Puppet::FileSystem.expects(:exist?).with("/a/manifests/init.pp").returns(true)
 
     expect(@mod.match_manifests(nil)).to eq(%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})
 
     expect(@mod.match_manifests(@pq_glob_with_extension)).to eq(%w{a b})
   end
 
   it "should match the glob pattern plus '.pp' if no extension is specified" do
     Dir.expects(:glob).with("/a/manifests/yay/foo.pp").returns(%w{yay})
 
     expect(@mod.match_manifests("yay/foo")).to eq(%w{yay})
   end
 
   it "should return an empty array if no manifests matched" do
     Dir.expects(:glob).with(@fq_glob_with_extension).returns([])
 
     expect(@mod.match_manifests(@pq_glob_with_extension)).to eq([])
   end
 
   it "should raise an error if the pattern tries to leave the manifest directory" do
     expect do
       @mod.match_manifests("something/../../*")
     end.to raise_error(Puppet::Module::InvalidFilePattern, 'The pattern "something/../../*" to find manifests in the module "mymod" is invalid and potentially unsafe.')
   end
 end
 
 describe Puppet::Module do
   include PuppetSpec::Files
   before do
     @modpath = tmpdir('modpath')
     @module = PuppetSpec::Modules.create('mymod', @modpath)
   end
 
   it "should use 'License' in its current path as its metadata file" do
     expect(@module.license_file).to eq("#{@modpath}/mymod/License")
   end
 
   it "should cache the license file" do
     @module.expects(:path).once.returns nil
     @module.license_file
     @module.license_file
   end
 
   it "should use 'metadata.json' in its current path as its metadata file" do
     expect(@module.metadata_file).to eq("#{@modpath}/mymod/metadata.json")
   end
 
   it "should have metadata if it has a metadata file and its data is not empty" do
     Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
     File.stubs(:read).with(@module.metadata_file).returns "{\"foo\" : \"bar\"}"
 
     expect(@module).to be_has_metadata
   end
 
   it "should have metadata if it has a metadata file and its data is not empty" do
     Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
     File.stubs(:read).with(@module.metadata_file).returns "{\"foo\" : \"bar\"}"
 
     expect(@module).to be_has_metadata
   end
 
   it "should not have metadata if has a metadata file and its data is empty" do
     Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
     File.stubs(:read).with(@module.metadata_file).returns "/*
 +-----------------------------------------------------------------------+
 |                                                                       |
 |                    ==> DO NOT EDIT THIS FILE! <==                     |
 |                                                                       |
 |   You should edit the `Modulefile` and run `puppet-module build`      |
 |   to generate the `metadata.json` file for your releases.             |
 |                                                                       |
 +-----------------------------------------------------------------------+
 */
 
 {}"
 
     expect(@module).not_to be_has_metadata
   end
 
   it "should know if it is missing a metadata file" do
     Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns false
 
     expect(@module).not_to be_has_metadata
   end
 
   it "should be able to parse its metadata file" do
     expect(@module).to 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", "/path", mock("env"))
   end
 
   it "should tolerate failure to parse" do
     Puppet::FileSystem.expects(:exist?).with(@module.metadata_file).returns true
     File.stubs(:read).with(@module.metadata_file).returns(my_fixture('trailing-comma.json'))
 
     expect(@module.has_metadata?).to be_falsey
   end
 
   def a_module_with_metadata(data)
     text = data.to_pson
 
     mod = Puppet::Module.new("foo", "/path", mock("env"))
     mod.stubs(:metadata_file).returns "/my/file"
     File.stubs(:read).with("/my/file").returns text
     mod
   end
 
   describe "when loading the metadata file" do
     before do
       @data = {
         :license       => "GPL2",
         :author        => "luke",
         :version       => "1.0",
         :source        => "http://foo/",
         :puppetversion => "0.25",
         :dependencies  => []
       }
       @module = a_module_with_metadata(@data)
     end
 
     %w{source author version license}.each do |attr|
       it "should set #{attr} if present in the metadata file" do
         @module.load_metadata
         expect(@module.send(attr)).to eq(@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_pson
         File.stubs(:read).with("/my/file").returns @text
         expect { @module.load_metadata }.to raise_error(
           Puppet::Module::MissingMetadata,
           "No #{attr} module metadata provided for foo"
         )
       end
     end
 
     it "should set puppetversion if present in the metadata file" do
       @module.load_metadata
       expect(@module.puppetversion).to eq(@data[:puppetversion])
     end
 
     context "when versionRequirement is used for dependency version info" do
       before do
         @data = {
           :license       => "GPL2",
           :author        => "luke",
           :version       => "1.0",
           :source        => "http://foo/",
           :puppetversion => "0.25",
           :dependencies  => [
             {
               "versionRequirement" => "0.0.1",
               "name" => "pmtacceptance/stdlib"
             },
             {
               "versionRequirement" => "0.1.0",
               "name" => "pmtacceptance/apache"
             }
           ]
         }
         @module = a_module_with_metadata(@data)
       end
 
       it "should set the dependency version_requirement key" do
         @module.load_metadata
         expect(@module.dependencies[0]['version_requirement']).to eq("0.0.1")
       end
 
       it "should set the version_requirement key for all dependencies" do
         @module.load_metadata
         expect(@module.dependencies[0]['version_requirement']).to eq("0.0.1")
         expect(@module.dependencies[1]['version_requirement']).to eq("0.1.0")
       end
     end
   end
 
   it "should be able to tell if there are local changes" do
     modpath = tmpdir('modpath')
     foo_checksum = 'acbd18db4cc2f85cedef654fccc4a4d8'
     checksummed_module = PuppetSpec::Modules.create(
       'changed',
       modpath,
       :metadata => {
         :checksums => {
           "foo" => foo_checksum,
         }
       }
     )
 
     foo_path = Pathname.new(File.join(checksummed_module.path, 'foo'))
 
     IO.binwrite(foo_path, 'notfoo')
     expect(Puppet::ModuleTool::Checksums.new(foo_path).checksum(foo_path)).not_to eq(foo_checksum)
 
     IO.binwrite(foo_path, 'foo')
     expect(Puppet::ModuleTool::Checksums.new(foo_path).checksum(foo_path)).to eq(foo_checksum)
   end
 
   it "should know what other modules require it" do
     env = Puppet::Node::Environment.create(:testing, [@modpath])
 
     dependable = PuppetSpec::Modules.create(
       'dependable',
       @modpath,
       :metadata => {:author => 'puppetlabs'},
       :environment => env
     )
     PuppetSpec::Modules.create(
       'needy',
       @modpath,
       :metadata => {
         :author => 'beggar',
         :dependencies => [{
             "version_requirement" => ">= 2.2.0",
             "name" => "puppetlabs/dependable"
         }]
       },
       :environment => env
     )
     PuppetSpec::Modules.create(
       'wantit',
       @modpath,
       :metadata => {
         :author => 'spoiled',
         :dependencies => [{
             "version_requirement" => "< 5.0.0",
             "name" => "puppetlabs/dependable"
         }]
       },
       :environment => env
     )
     expect(dependable.required_by).to match_array([
       {
         "name"    => "beggar/needy",
         "version" => "9.9.9",
         "version_requirement" => ">= 2.2.0"
       },
       {
         "name"    => "spoiled/wantit",
         "version" => "9.9.9",
         "version_requirement" => "< 5.0.0"
       }
     ])
   end
 end