diff --git a/lib/puppet/forge.rb b/lib/puppet/forge.rb
index b985f0fa8..d43114b80 100644
--- a/lib/puppet/forge.rb
+++ b/lib/puppet/forge.rb
@@ -1,202 +1,199 @@
 require 'puppet/vendor'
 Puppet::Vendor.load_vendored
 
 require 'net/http'
 require 'tempfile'
 require 'uri'
 require 'pathname'
 require 'json'
 require 'semantic'
 
 class Puppet::Forge < Semantic::Dependency::Source
   require 'puppet/forge/cache'
   require 'puppet/forge/repository'
   require 'puppet/forge/errors'
 
   include Puppet::Forge::Errors
 
   USER_AGENT = "PMT/1.1.1 (v3; Net::HTTP)".freeze
 
   attr_reader :host, :repository
 
   def initialize(host = Puppet[:module_repository])
     @host = host
     @repository = Puppet::Forge::Repository.new(host, USER_AGENT)
   end
 
   # Return a list of module metadata hashes that match the search query.
   # This return value is used by the module_tool face install search,
   # and displayed to on the console.
   #
   # Example return value:
   #
   # [
   #   {
   #     "author"      => "puppetlabs",
   #     "name"        => "bacula",
   #     "tag_list"    => ["backup", "bacula"],
   #     "releases"    => [{"version"=>"0.0.1"}, {"version"=>"0.0.2"}],
   #     "full_name"   => "puppetlabs/bacula",
   #     "version"     => "0.0.2",
   #     "project_url" => "http://github.com/puppetlabs/puppetlabs-bacula",
   #     "desc"        => "bacula"
   #   }
   # ]
   #
   # @param term [String] search term
   # @return [Array] modules found
   # @raise [Puppet::Forge::Errors::CommunicationError] if there is a network
   #   related error
   # @raise [Puppet::Forge::Errors::SSLVerifyError] if there is a problem
   #   verifying the remote SSL certificate
   # @raise [Puppet::Forge::Errors::ResponseError] if the repository returns a
   #   bad HTTP response
   def search(term)
     matches = []
     uri = "/v3/modules?query=#{URI.escape(term)}"
 
     while uri
       response = make_http_request(uri)
 
       if response.code == '200'
         result = JSON.parse(response.body)
         uri = result['pagination']['next']
         matches.concat result['results']
       else
         raise ResponseError.new(:uri => URI.parse(@host).merge(uri) , :input => term, :response => response)
       end
     end
 
     matches.each do |mod|
       mod['author'] = mod['owner']['username']
       mod['tag_list'] = mod['current_release']['tags']
       mod['full_name'] = "#{mod['author']}/#{mod['name']}"
       mod['version'] = mod['current_release']['version']
       mod['project_url'] = mod['homepage_url']
       mod['desc'] = mod['current_release']['metadata']['summary'] || ''
     end
   end
 
   # Fetches {ModuleRelease} entries for each release of the named module.
   #
   # @param input [String] the module name to look up
   # @return [Array<Semantic::Dependency::ModuleRelease>] a list of releases for
   #         the given name
   # @see Semantic::Dependency::Source#fetch
   def fetch(input)
     name = input.tr('/', '-')
     uri = "/v3/releases?module=#{name}"
     releases = []
 
     while uri
       response = make_http_request(uri)
 
       if response.code == '200'
         response = JSON.parse(response.body)
       else
         raise ResponseError.new(:uri => URI.parse(@host).merge(uri), :input => input, :response => response)
       end
 
       releases.concat(process(response['results']))
       uri = response['pagination']['next']
     end
 
     return releases
   end
 
   def make_http_request(*args)
     @repository.make_http_request(*args)
   end
 
   class ModuleRelease < Semantic::Dependency::ModuleRelease
     attr_reader :install_dir, :metadata
 
     def initialize(source, data)
       @data = data
       @metadata = meta = data['metadata']
 
       name = meta['name'].tr('/', '-')
       version = Semantic::Version.parse(meta['version'])
+      release = "#{name}@#{version}"
 
       dependencies = (meta['dependencies'] || [])
       dependencies.map! do |dep|
-        range = dep['version_requirement'] || dep['versionRequirement'] || '>=0'
-        [
-          dep['name'].tr('/', '-'),
-          (Semantic::VersionRange.parse(range) rescue Semantic::VersionRange::EMPTY_RANGE),
-        ]
+        Puppet::ModuleTool.parse_module_dependency(release, dep)[0..1]
       end
 
       super(source, name, version, Hash[dependencies])
     end
 
     def install(dir)
       staging_dir = self.prepare
 
       module_dir = dir + name[/-(.*)/, 1]
       module_dir.rmtree if module_dir.exist?
 
       # Make sure unpacked module has the same ownership as the folder we are moving it into.
       Puppet::ModuleTool::Applications::Unpacker.harmonize_ownership(dir, staging_dir)
 
       FileUtils.mv(staging_dir, module_dir)
       @install_dir = dir
 
       # Return the Pathname object representing the directory where the
       # module release archive was unpacked the to.
       return module_dir
     ensure
       staging_dir.rmtree if staging_dir.exist?
     end
 
     def prepare
       return @unpacked_into if @unpacked_into
 
       download(@data['file_uri'], tmpfile)
       validate_checksum(tmpfile, @data['file_md5'])
       unpack(tmpfile, tmpdir)
 
       @unpacked_into = Pathname.new(tmpdir)
     end
 
     private
 
     # Obtain a suitable temporary path for unpacking tarballs
     #
     # @return [Pathname] path to temporary unpacking location
     def tmpdir
       @dir ||= Dir.mktmpdir(name, Puppet::Forge::Cache.base_path)
     end
 
     def tmpfile
       @file ||= Tempfile.new(name, Puppet::Forge::Cache.base_path).tap do |f|
         f.binmode
       end
     end
 
     def download(uri, destination)
       @source.make_http_request(uri, destination)
       destination.flush and destination.close
     end
 
     def validate_checksum(file, checksum)
       if Digest::MD5.file(file.path).hexdigest != checksum
         raise RuntimeError, "Downloaded release for #{name} did not match expected checksum"
       end
     end
 
     def unpack(file, destination)
       begin
         Puppet::ModuleTool::Applications::Unpacker.unpack(file.path, destination)
       rescue Puppet::ExecutionFailure => e
         raise RuntimeError, "Could not extract contents of module archive: #{e.message}"
       end
     end
   end
 
   private
 
   def process(list)
     list.map { |release| ModuleRelease.new(self, release) }
   end
 end
diff --git a/lib/puppet/module_tool.rb b/lib/puppet/module_tool.rb
index 6ab3e9ca2..8a34d26d1 100644
--- a/lib/puppet/module_tool.rb
+++ b/lib/puppet/module_tool.rb
@@ -1,169 +1,192 @@
 # encoding: UTF-8
 # Load standard libraries
 require 'pathname'
 require 'fileutils'
 require 'puppet/util/colors'
 
 module Puppet
   module ModuleTool
     require 'puppet/module_tool/tar'
     extend Puppet::Util::Colors
 
     # Directory and names that should not be checksummed.
     ARTIFACTS = ['pkg', /^\./, /^~/, /^#/, 'coverage', 'checksums.json', 'REVISION']
     FULL_MODULE_NAME_PATTERN = /\A([^-\/|.]+)[-|\/](.+)\z/
     REPOSITORY_URL = Puppet.settings[:module_repository]
 
     # Is this a directory that shouldn't be checksummed?
     #
     # TODO: Should this be part of Checksums?
     # TODO: Rename this method to reflect its purpose?
     # TODO: Shouldn't this be used when building packages too?
     def self.artifact?(path)
       case File.basename(path)
       when *ARTIFACTS
         true
       else
         false
       end
     end
 
     # Return the +username+ and +modname+ for a given +full_module_name+, or raise an
     # ArgumentError if the argument isn't parseable.
     def self.username_and_modname_from(full_module_name)
       if matcher = full_module_name.match(FULL_MODULE_NAME_PATTERN)
         return matcher.captures
       else
         raise ArgumentError, "Not a valid full name: #{full_module_name}"
       end
     end
 
     # Find the module root when given a path by checking each directory up from
     # its current location until it finds one that contains a file called
     # 'Modulefile'.
     #
     # @param path [Pathname, String] path to start from
     # @return [Pathname, nil] the root path of the module directory or nil if
     #   we cannot find one
     def self.find_module_root(path)
       path = Pathname.new(path) if path.class == String
 
       path.expand_path.ascend do |p|
         return p if is_module_root?(p)
       end
 
       nil
     end
 
     # Analyse path to see if it is a module root directory by detecting a
     # file named 'metadata.json' or 'Modulefile' in the directory.
     #
     # @param path [Pathname, String] path to analyse
     # @return [Boolean] true if the path is a module root, false otherwise
     def self.is_module_root?(path)
       path = Pathname.new(path) if path.class == String
 
       FileTest.file?(path + 'metadata.json') || FileTest.file?(path + 'Modulefile')
     end
 
     # Builds a formatted tree from a list of node hashes containing +:text+
     # and +:dependencies+ keys.
     def self.format_tree(nodes, level = 0)
       str = ''
       nodes.each_with_index do |node, i|
         last_node = nodes.length - 1 == i
         deps = node[:dependencies] || []
 
         str << (indent = "  " * level)
         str << (last_node ? "└" : "├")
         str << "─"
         str << (deps.empty? ? "─" : "┬")
         str << " #{node[:text]}\n"
 
         branch = format_tree(deps, level + 1)
         branch.gsub!(/^#{indent} /, indent + '│') unless last_node
         str << branch
       end
 
       return str
     end
 
     def self.build_tree(mods, dir)
       mods.each do |mod|
         version_string = mod[:version].to_s.sub(/^(?!v)/, 'v')
 
         if mod[:action] == :upgrade
           previous_version = mod[:previous_version].to_s.sub(/^(?!v)/, 'v')
           version_string = "#{previous_version} -> #{version_string}"
         end
 
         mod[:text] = "#{mod[:name]} (#{colorize(:cyan, version_string)})"
         mod[:text] += " [#{mod[:path]}]" unless mod[:path].to_s == dir.to_s
 
         deps = (mod[:dependencies] || [])
         deps.sort! { |a, b| a[:name] <=> b[:name] }
         build_tree(deps, dir)
       end
     end
 
     # @param options [Hash<Symbol,String>] This hash will contain any
     #   command-line arguments that are not Settings, as those will have already
     #   been extracted by the underlying application code.
     #
     # @note Unfortunately the whole point of this method is the side effect of
     # modifying the options parameter.  This same hash is referenced both
     # when_invoked and when_rendering.  For this reason, we are not returning
     # a duplicate.
     # @todo Validate the above note...
     #
     # An :environment_instance and a :target_dir are added/updated in the
     # options parameter.
     #
     # @api private
     def self.set_option_defaults(options)
       current_environment = environment_from_options(options)
 
       modulepath = [options[:target_dir]] + current_environment.full_modulepath
 
       face_environment = current_environment.override_with(:modulepath => modulepath.compact)
 
       options[:environment_instance] = face_environment
 
       # Note: environment will have expanded the path
       options[:target_dir] = face_environment.full_modulepath.first
     end
 
     # Given a hash of options, we should discover or create a
     # {Puppet::Node::Environment} instance that reflects the provided options.
     #
     # Generally speaking, the `:modulepath` parameter should supercede all
     # others, the `:environment` parameter should follow after that, and we
     # should default to Puppet's current environment.
     #
     # @param options [{Symbol => Object}] the options to derive environment from
     # @return [Puppet::Node::Environment] the environment described by the options
     def self.environment_from_options(options)
       if options[:modulepath]
         path = options[:modulepath].split(File::PATH_SEPARATOR)
         Puppet::Node::Environment.create(:anonymous, path, '')
       elsif options[:environment].is_a?(Puppet::Node::Environment)
         options[:environment]
       elsif options[:environment]
         Puppet.lookup(:environments).get(options[:environment])
       else
         Puppet.lookup(:current_environment)
       end
     end
+
+    # Handles parsing of module dependency expressions into proper
+    # {Semantic::VersionRange}s, including reasonable error handling.
+    #
+    # @param where [String] a description of the thing we're parsing the
+    #        dependency expression for
+    # @param dep [Hash] the dependency description to parse
+    # @return [Array(String, Semantic::VersionRange, String)] an tuple of the
+    #         dependent module's name, the version range dependency, and the
+    #         unparsed range expression.
+    def self.parse_module_dependency(where, dep)
+      dep_name = dep['name'].tr('/', '-')
+      range = dep['version_requirement'] || dep['versionRequirement'] || '>= 0.0.0'
+
+      begin
+        parsed_range = Semantic::VersionRange.parse(range)
+      rescue ArgumentError => e
+        Puppet.debug "Error in #{where} parsing dependency #{dep_name} (#{e.message}); using empty range."
+        parsed_range = Semantic::VersionRange::EMPTY_RANGE
+      end
+
+      [ dep_name, parsed_range, range ]
+    end
   end
 end
 
 # Load remaining libraries
 require 'puppet/module_tool/errors'
 require 'puppet/module_tool/applications'
 require 'puppet/module_tool/checksums'
 require 'puppet/module_tool/contents_description'
 require 'puppet/module_tool/dependency'
 require 'puppet/module_tool/metadata'
 require 'puppet/module_tool/modulefile'
 require 'puppet/forge/cache'
 require 'puppet/forge'
diff --git a/lib/puppet/module_tool/installed_modules.rb b/lib/puppet/module_tool/installed_modules.rb
index da27a0404..0e82b6bd0 100644
--- a/lib/puppet/module_tool/installed_modules.rb
+++ b/lib/puppet/module_tool/installed_modules.rb
@@ -1,92 +1,93 @@
 require 'pathname'
 
 require 'puppet/forge'
 require 'puppet/module_tool'
 
 module Puppet::ModuleTool
   class InstalledModules < Semantic::Dependency::Source
     attr_reader :modules, :by_name
 
     def priority
       10
     end
 
     def initialize(env)
       @env = env
       modules = env.modules_by_path
 
       @fetched = []
       @modules = {}
       @by_name = {}
       env.modulepath.each do |path|
         modules[path].each do |mod|
           @by_name[mod.name] = mod
           next unless mod.has_metadata?
           release = ModuleRelease.new(self, mod)
           @modules[release.name] ||= release
         end
       end
 
       @modules.freeze
     end
 
     # Fetches {ModuleRelease} entries for each release of the named module.
     #
     # @param name [String] the module name to look up
     # @return [Array<Semantic::Dependency::ModuleRelease>] a list of releases for
     #         the given name
     # @see Semantic::Dependency::Source#fetch
     def fetch(name)
       name = name.tr('/', '-')
 
       if @modules.key? name
         @fetched << name
         [ @modules[name] ]
       else
         [ ]
       end
     end
 
     def fetched
       @fetched
     end
 
     class ModuleRelease < Semantic::Dependency::ModuleRelease
       attr_reader :mod, :metadata
 
       def initialize(source, mod)
         @mod = mod
         @metadata = mod.metadata
         name = mod.forge_name.tr('/', '-')
         version = Semantic::Version.parse(mod.version)
+        release = "#{name}@#{version}"
 
         super(source, name, version, {})
 
         if mod.dependencies
           mod.dependencies.each do |dep|
-            range = dep['version_requirement'] || dep['versionRequirement'] || '>=0'
-            range = Semantic::VersionRange.parse(range) rescue Semantic::VersionRange::EMPTY_RANGE
+            results = Puppet::ModuleTool.parse_module_dependency(release, dep)
+            dep_name, parsed_range, range = results
 
             dep.tap do |dep|
-              add_constraint('initialize', dep['name'].tr('/', '-'), range.to_s) do |node|
-                range === node.version
+              add_constraint('initialize', dep_name, range.to_s) do |node|
+                parsed_range === node.version
               end
             end
           end
         end
       end
 
       def install_dir
         Pathname.new(@mod.path).dirname
       end
 
       def install(dir)
         # If we're already installed, there's no need for us to faff about.
       end
 
       def prepare
         # We're already installed; what preparation remains?
       end
     end
   end
 end
diff --git a/lib/puppet/module_tool/local_tarball.rb b/lib/puppet/module_tool/local_tarball.rb
index b366df3a1..d85c4c0fa 100644
--- a/lib/puppet/module_tool/local_tarball.rb
+++ b/lib/puppet/module_tool/local_tarball.rb
@@ -1,91 +1,90 @@
 require 'pathname'
 require 'tmpdir'
 
 require 'puppet/forge'
 require 'puppet/module_tool'
 
 module Puppet::ModuleTool
   class LocalTarball < Semantic::Dependency::Source
     attr_accessor :release
 
     def initialize(filename)
       unpack(filename, tmpdir)
       Puppet.debug "Unpacked local tarball to #{tmpdir}"
 
       mod = Puppet::Module.new('tarball', tmpdir, nil)
       @release = ModuleRelease.new(self, mod)
     end
 
     def fetch(name)
       if @release.name == name
         [ @release ]
       else
         [ ]
       end
     end
 
     def prepare(release)
       release.mod.path
     end
 
     def install(release, dir)
       staging_dir = release.prepare
 
       module_dir = dir + release.name[/-(.*)/, 1]
       module_dir.rmtree if module_dir.exist?
 
       # Make sure unpacked module has the same ownership as the folder we are moving it into.
       Puppet::ModuleTool::Applications::Unpacker.harmonize_ownership(dir, staging_dir)
 
       FileUtils.mv(staging_dir, module_dir)
     end
 
     class ModuleRelease < Semantic::Dependency::ModuleRelease
       attr_reader :mod, :install_dir, :metadata
 
       def initialize(source, mod)
         @mod = mod
         @metadata = mod.metadata
         name = mod.forge_name.tr('/', '-')
         version = Semantic::Version.parse(mod.version)
+        release = "#{name}@#{version}"
 
         if mod.dependencies
           dependencies = mod.dependencies.map do |dep|
-            range = dep['version_requirement'] || dep['versionRequirement'] || '>=0'
-            range = Semantic::VersionRange.parse(range) rescue Semantic::VersionRange::EMPTY_RANGE
-            [ dep['name'].tr('/', '-'), range ]
+            Puppet::ModuleTool.parse_module_dependency(release, dep)[0..1]
           end
           dependencies = Hash[dependencies]
         end
 
         super(source, name, version, dependencies || {})
       end
 
       def install(dir)
         @source.install(self, dir)
         @install_dir = dir
       end
 
       def prepare
         @source.prepare(self)
       end
     end
 
     private
 
     # Obtain a suitable temporary path for unpacking tarballs
     #
     # @return [String] path to temporary unpacking location
     def tmpdir
       @dir ||= Dir.mktmpdir('local-tarball', Puppet::Forge::Cache.base_path)
     end
 
     def unpack(file, destination)
       begin
         Puppet::ModuleTool::Applications::Unpacker.unpack(file, destination)
       rescue Puppet::ExecutionFailure => e
         raise RuntimeError, "Could not extract contents of module archive: #{e.message}"
       end
     end
   end
 end
diff --git a/lib/puppet/vendor/semantic/lib/semantic/dependency/source.rb b/lib/puppet/vendor/semantic/lib/semantic/dependency/source.rb
index 575365160..f052281ed 100644
--- a/lib/puppet/vendor/semantic/lib/semantic/dependency/source.rb
+++ b/lib/puppet/vendor/semantic/lib/semantic/dependency/source.rb
@@ -1,25 +1,25 @@
 require 'semantic/dependency'
 
 module Semantic
   module Dependency
     class Source
       def self.priority
         0
       end
 
       def priority
         self.class.priority
       end
 
       def create_release(name, version, dependencies = {})
         version = Version.parse(version) if version.is_a? String
         dependencies = dependencies.inject({}) do |hash, (key, value)|
-          hash[key] = VersionRange.parse(value || '>= 0')
+          hash[key] = VersionRange.parse(value || '>= 0.0.0')
           hash[key] ||= VersionRange::EMPTY_RANGE
           hash
         end
         ModuleRelease.new(self, name, version, dependencies)
       end
     end
   end
 end
diff --git a/spec/unit/module_tool_spec.rb b/spec/unit/module_tool_spec.rb
index 8320cedf5..dee8e13bf 100755
--- a/spec/unit/module_tool_spec.rb
+++ b/spec/unit/module_tool_spec.rb
@@ -1,300 +1,330 @@
 #! /usr/bin/env ruby
 # encoding: UTF-8
 
 require 'spec_helper'
 require 'puppet/module_tool'
 
 describe Puppet::ModuleTool do
   describe '.is_module_root?' do
     it 'should return true if directory has a Modulefile file' do
       FileTest.expects(:file?).with(responds_with(:to_s, '/a/b/c/metadata.json')).
         returns(false)
       FileTest.expects(:file?).with(responds_with(:to_s, '/a/b/c/Modulefile')).
         returns(true)
 
       subject.is_module_root?(Pathname.new('/a/b/c')).should be_true
     end
 
     it 'should return true if directory has a metadata.json file' do
       FileTest.expects(:file?).with(responds_with(:to_s, '/a/b/c/metadata.json')).
         returns(true)
 
       subject.is_module_root?(Pathname.new('/a/b/c')).should be_true
     end
 
     it 'should return false if directory does not have a metadata.json or a Modulefile file' do
       FileTest.expects(:file?).with(responds_with(:to_s, '/a/b/c/metadata.json')).
         returns(false)
       FileTest.expects(:file?).with(responds_with(:to_s, '/a/b/c/Modulefile')).
         returns(false)
 
       subject.is_module_root?(Pathname.new('/a/b/c')).should be_false
     end
   end
 
   describe '.find_module_root' do
     let(:sample_path) { Pathname.new('/a/b/c').expand_path }
 
     it 'should return the first path as a pathname when it contains a module file' do
       Puppet::ModuleTool.expects(:is_module_root?).with(sample_path).
         returns(true)
 
       subject.find_module_root(sample_path).should == sample_path
     end
 
     it 'should return a parent path as a pathname when it contains a module file' do
       Puppet::ModuleTool.expects(:is_module_root?).
         with(responds_with(:to_s, File.expand_path('/a/b/c'))).returns(false)
       Puppet::ModuleTool.expects(:is_module_root?).
         with(responds_with(:to_s, File.expand_path('/a/b'))).returns(true)
 
       subject.find_module_root(sample_path).should == Pathname.new('/a/b').expand_path
     end
 
     it 'should return nil when no module root can be found' do
       Puppet::ModuleTool.expects(:is_module_root?).at_least_once.returns(false)
       subject.find_module_root(sample_path).should be_nil
     end
   end
 
   describe '.format_tree' do
     it 'should return an empty tree when given an empty list' do
       subject.format_tree([]).should == ''
     end
 
     it 'should return a shallow when given a list without dependencies' do
       list = [ { :text => 'first' }, { :text => 'second' }, { :text => 'third' } ]
       subject.format_tree(list).should == <<-TREE
 ├── first
 ├── second
 └── third
 TREE
     end
 
     it 'should return a deeply nested tree when given a list with deep dependencies' do
       list = [
         {
           :text => 'first',
           :dependencies => [
             {
               :text => 'second',
               :dependencies => [
                 { :text => 'third' }
               ]
             }
           ]
         },
       ]
       subject.format_tree(list).should == <<-TREE
 └─┬ first
   └─┬ second
     └── third
 TREE
     end
 
     it 'should show connectors when deep dependencies are not on the last node of the top level' do
       list = [
         {
           :text => 'first',
           :dependencies => [
             {
               :text => 'second',
               :dependencies => [
                 { :text => 'third' }
               ]
             }
           ]
         },
         { :text => 'fourth' }
       ]
       subject.format_tree(list).should == <<-TREE
 ├─┬ first
 │ └─┬ second
 │   └── third
 └── fourth
 TREE
     end
 
     it 'should show connectors when deep dependencies are not on the last node of any level' do
       list = [
         {
           :text => 'first',
           :dependencies => [
             {
               :text => 'second',
               :dependencies => [
                 { :text => 'third' }
               ]
             },
             { :text => 'fourth' }
           ]
         }
       ]
       subject.format_tree(list).should == <<-TREE
 └─┬ first
   ├─┬ second
   │ └── third
   └── fourth
 TREE
     end
 
     it 'should show connectors in every case when deep dependencies are not on the last node' do
       list = [
         {
           :text => 'first',
           :dependencies => [
             {
               :text => 'second',
               :dependencies => [
                 { :text => 'third' }
               ]
             },
             { :text => 'fourth' }
           ]
         },
         { :text => 'fifth' }
       ]
       subject.format_tree(list).should == <<-TREE
 ├─┬ first
 │ ├─┬ second
 │ │ └── third
 │ └── fourth
 └── fifth
 TREE
     end
   end
 
   describe '.set_option_defaults' do
     let(:options) { {} }
     let(:modulepath) { ['/env/module/path', '/global/module/path'] }
     let(:environment_name) { :current_environment }
     let(:environment) { Puppet::Node::Environment.create(environment_name, modulepath) }
 
     subject do
       described_class.set_option_defaults(options)
       options
     end
 
     around do |example|
       envs = Puppet::Environments::Combined.new(
         Puppet::Environments::Static.new(environment),
         Puppet::Environments::Legacy.new
       )
 
       Puppet.override(:environments => envs) do
         example.run
       end
     end
 
     describe ':environment' do
       context 'as String' do
         let(:options) { { :environment => "#{environment_name}" } }
 
         it 'assigns the environment with the given name to :environment_instance' do
           expect(subject).to include :environment_instance => environment
         end
       end
 
       context 'as Symbol' do
         let(:options) { { :environment => :"#{environment_name}" } }
 
         it 'assigns the environment with the given name to :environment_instance' do
           expect(subject).to include :environment_instance => environment
         end
       end
 
       context 'as Puppet::Node::Environment' do
         let(:env) { Puppet::Node::Environment.create('anonymous', []) }
         let(:options) { { :environment => env } }
 
         it 'assigns the given environment to :environment_instance' do
           expect(subject).to include :environment_instance => env
         end
       end
     end
 
     describe ':modulepath' do
       let(:options) do
         { :modulepath => %w[bar foo baz].join(File::PATH_SEPARATOR) }
       end
 
       let(:paths) { options[:modulepath].split(File::PATH_SEPARATOR).map { |dir| File.expand_path(dir) } }
 
       it 'is expanded to an absolute path' do
         expect(subject[:environment_instance].full_modulepath).to eql paths
       end
 
       it 'is used to compute :target_dir' do
         expect(subject).to include :target_dir => paths.first
       end
 
       context 'conflicts with :environment' do
         let(:options) do
           { :modulepath => %w[bar foo baz].join(File::PATH_SEPARATOR), :environment => environment_name }
         end
 
         it 'replaces the modulepath of the :environment_instance' do
           expect(subject[:environment_instance].full_modulepath).to eql paths
         end
 
         it 'is used to compute :target_dir' do
           expect(subject).to include :target_dir => paths.first
         end
       end
     end
 
     describe ':target_dir' do
       let(:options) do
         { :target_dir => 'foo' }
       end
 
       let(:target) { File.expand_path(options[:target_dir]) }
 
       it 'is expanded to an absolute path' do
         expect(subject).to include :target_dir => target
       end
 
       it 'is prepended to the modulepath of the :environment_instance' do
         expect(subject[:environment_instance].full_modulepath.first).to eql target
       end
 
       context 'conflicts with :modulepath' do
         let(:options) do
           { :target_dir => 'foo', :modulepath => %w[bar foo baz].join(File::PATH_SEPARATOR) }
         end
 
         it 'is prepended to the modulepath of the :environment_instance' do
           expect(subject[:environment_instance].full_modulepath.first).to eql target
         end
 
         it 'shares the provided :modulepath via the :environment_instance' do
           paths = %w[foo] + options[:modulepath].split(File::PATH_SEPARATOR)
           paths.map! { |dir| File.expand_path(dir) }
           expect(subject[:environment_instance].full_modulepath).to eql paths
         end
       end
 
       context 'conflicts with :environment' do
         let(:options) do
           { :target_dir => 'foo', :environment => environment_name }
         end
 
         it 'is prepended to the modulepath of the :environment_instance' do
           expect(subject[:environment_instance].full_modulepath.first).to eql target
         end
 
         it 'shares the provided :modulepath via the :environment_instance' do
           paths = %w[foo] + environment.full_modulepath
           paths.map! { |dir| File.expand_path(dir) }
           expect(subject[:environment_instance].full_modulepath).to eql paths
         end
       end
 
       context 'when not passed' do
         it 'is populated with the first component of the modulepath' do
           expect(subject).to include :target_dir => subject[:environment_instance].full_modulepath.first
         end
       end
     end
   end
+
+  describe '.parse_module_dependency' do
+    it 'parses a dependency without a version range expression' do
+      name, range, expr = subject.parse_module_dependency('source', 'name' => 'foo-bar')
+      expect(name).to eql('foo-bar')
+      expect(range).to eql(Semantic::VersionRange.parse('>= 0.0.0'))
+      expect(expr).to eql('>= 0.0.0')
+    end
+
+    it 'parses a dependency with a version range expression' do
+      name, range, expr = subject.parse_module_dependency('source', 'name' => 'foo-bar', 'version_requirement' => '1.2.x')
+      expect(name).to eql('foo-bar')
+      expect(range).to eql(Semantic::VersionRange.parse('1.2.x'))
+      expect(expr).to eql('1.2.x')
+    end
+
+    it 'parses a dependency with a version range expression in the (deprecated) versionRange key' do
+      name, range, expr = subject.parse_module_dependency('source', 'name' => 'foo-bar', 'versionRequirement' => '1.2.x')
+      expect(name).to eql('foo-bar')
+      expect(range).to eql(Semantic::VersionRange.parse('1.2.x'))
+      expect(expr).to eql('1.2.x')
+    end
+
+    it 'does not raise an error on invalid version range expressions' do
+      name, range, expr = subject.parse_module_dependency('source', 'name' => 'foo-bar', 'version_requirement' => 'nope')
+      expect(name).to eql('foo-bar')
+      expect(range).to eql(Semantic::VersionRange::EMPTY_RANGE)
+      expect(expr).to eql('nope')
+    end
+  end
 end