puppetfile-resolver 0.1.0

data/lib/puppetfile-resolver/spec_searchers/common.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module PuppetfileResolver
+  module SpecSearchers
+    module Common
+      def self.dependency_cache_id(caller, dependency)
+        "#{caller}-#{dependency.owner}-#{dependency.name}"
+      end
+
+      def self.specification_cache_id(caller, specification)
+        "#{caller}-#{specification.owner}-#{specification.name}-#{specification.version}"
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/spec_searchers/forge.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'puppetfile-resolver/spec_searchers/common'
+require 'uri'
+require 'net/http'
+require 'openssl'
+require 'json'
+
+module PuppetfileResolver
+  module SpecSearchers
+    module Forge
+      DEFAULT_FORGE_URI ||= 'https://forgeapi.puppet.com'
+
+      def self.find_all(dependency, cache, resolver_ui)
+        dep_id = ::PuppetfileResolver::SpecSearchers::Common.dependency_cache_id(self, dependency)
+
+        # Has the information been cached?
+        return cache.load(dep_id) if cache.exist?(dep_id)
+
+        result = []
+        # Query the forge
+        fetch_all_module_releases(dependency.owner, dependency.name, resolver_ui) do |partial_releases|
+          partial_releases.each do |release|
+            result << Models::ModuleSpecification.new(
+              name: release['module']['name'],
+              owner: release['module']['owner']['slug'],
+              origin: :forge,
+              version: release['version'],
+              metadata: ::PuppetfileResolver::Util.symbolise_object(release['metadata'])
+            )
+          end
+        end
+
+        cache.save(dep_id, result)
+        result
+      end
+
+      def self.fetch_all_module_releases(owner, name, forge_api_url = DEFAULT_FORGE_URI, resolver_ui, &block)
+        raise 'Requires a block to yield' unless block
+        uri = ::URI.parse("#{forge_api_url}/v3/releases")
+        params = { :module => "#{owner}-#{name}", :exclude_fields => 'readme changelog license reference tasks', :limit => 50 }
+        uri.query = ::URI.encode_www_form(params)
+
+        loops = 0
+        loop do
+          resolver_ui.debug { "Querying the forge for a module with #{uri}" }
+
+          http_options = { :use_ssl => uri.class == URI::HTTPS }
+          # Because on Windows Ruby doesn't use the Windows certificate store which has up-to date
+          # CA certs, we can't depend on someone setting the environment variable correctly. So use our
+          # static CA PEM file if SSL_CERT_FILE is not set.
+          http_options[:ca_file] = PuppetfileResolver::Util.static_ca_cert_file if ENV['SSL_CERT_FILE'].nil?
+
+          response = nil
+          Net::HTTP.start(uri.host, uri.port, http_options) do |http|
+            request = Net::HTTP::Get.new uri
+            response = http.request request
+          end
+          raise "Expected HTTP Code 200, but received #{response.code} for URI #{uri}: #{response.inspect}" unless response.code == '200'
+
+          reply = ::JSON.parse(response.body)
+          yield reply['results']
+
+          break if reply['pagination'].nil? || reply['pagination']['next'].nil?
+          uri = ::URI.parse("#{forge_api_url}#{reply['pagination']['next']}")
+
+          # Circuit breaker in case the worst happens (max 1000 module releases)
+          loops += 1
+          raise "Too many Forge API requests #{loops * 50}" if loops > 20
+        end
+      end
+      private_class_method :fetch_all_module_releases
+    end
+  end
+end

data/lib/puppetfile-resolver/spec_searchers/git.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'puppetfile-resolver/spec_searchers/common'
+
+module PuppetfileResolver
+  module SpecSearchers
+    module Git
+      def self.find_all(puppetfile_module, dependency, cache, resolver_ui)
+        dep_id = ::PuppetfileResolver::SpecSearchers::Common.dependency_cache_id(self, dependency)
+        # Has the information been cached?
+        return cache.load(dep_id) if cache.exist?(dep_id)
+
+        # We _could_ git clone this, but it'll take too long. So for now, just
+        # try and resolve github based repositories by crafting a URL
+
+        repo_url = nil
+        if puppetfile_module.remote.start_with?('git@github.com:')
+          repo_url = puppetfile_module.remote.slice(15..-1)
+          repo_url = repo_url.slice(0..-5) if repo_url.end_with?('.git')
+        end
+        if puppetfile_module.remote.start_with?('https://github.com/')
+          repo_url = puppetfile_module.remote.slice(19..-1)
+          repo_url = repo_url.slice(0..-5) if repo_url.end_with?('.git')
+        end
+
+        return [] if repo_url.nil?
+
+        metadata_url = 'https://raw.githubusercontent.com/' + repo_url + '/'
+        if puppetfile_module.ref
+          metadata_url += puppetfile_module.ref + '/'
+        elsif puppetfile_module.tag
+          metadata_url += puppetfile_module.tag + '/'
+        else
+          # Default to master.  Should it raise?
+          metadata_url += 'master/'
+        end
+        metadata_url += 'metadata.json'
+
+        require 'net/http'
+        require 'uri'
+
+        resolver_ui.debug { "Querying the Github with #{metadata_url}" }
+        response = Net::HTTP.get_response(URI.parse(metadata_url))
+        if response.code != '200'
+          cache.save(dep_id, [])
+          return []
+        end
+
+        # TODO: symbolise_object should be in a Util namespace
+        metadata = ::PuppetfileResolver::Util.symbolise_object(::JSON.parse(response.body))
+        result = [Models::ModuleSpecification.new(
+          name: metadata[:name],
+          origin: :git,
+          version: metadata[:version],
+          metadata: metadata
+        )]
+
+        cache.save(dep_id, result)
+
+        result
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/spec_searchers/local.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'puppetfile-resolver/spec_searchers/common'
+
+module PuppetfileResolver
+  module SpecSearchers
+    module Local
+      def self.find_all(_puppetfile_module, puppet_module_paths, dependency, cache, resolver_ui)
+        dep_id = ::PuppetfileResolver::SpecSearchers::Common.dependency_cache_id(self, dependency)
+        # Has the information been cached?
+        return cache.load(dep_id) if cache.exist?(dep_id)
+
+        result = []
+        # Find the module in the modulepaths
+        puppet_module_paths.each do |module_path|
+          next unless Dir.exist?(module_path)
+          module_dir = File.expand_path(File.join(module_path, dependency.name))
+          next unless Dir.exist?(module_dir)
+          metadata_file = File.join(module_dir, 'metadata.json')
+          next unless File.exist?(metadata_file)
+
+          metadata = nil
+          begin
+            metadata = ::PuppetfileResolver::Util.symbolise_object(
+              ::JSON.parse(File.open(metadata_file, 'rb:utf-8') { |f| f.read })
+            )
+          rescue StandardError => _e # rubocop:disable Lint/SuppressedException Todo
+            # TODO: Should really do something?
+          end
+          resolver_ui.debug { "Found local module at #{metadata_file}" }
+
+          result << Models::ModuleSpecification.new(
+            name: metadata[:name],
+            origin: :local,
+            version: metadata[:version],
+            metadata: metadata
+          )
+        end
+        cache.save(dep_id, result)
+
+        result
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/ui/debug_ui.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'molinillo'
+
+module PuppetfileResolver
+  module UI
+    class DebugUI
+      include Molinillo::UI
+
+      def debug?
+        true
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/ui/null_ui.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'molinillo'
+
+module PuppetfileResolver
+  module UI
+    class NullUI
+      include Molinillo::UI
+
+      # Suppress all output
+      def output
+        @output ||= File.open(File::NULL, 'w')
+      end
+
+      def debug?
+        false
+      end
+    end
+  end
+end

data/lib/puppetfile-resolver/util.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module PuppetfileResolver
+  module Util
+    def self.symbolise_object(object)
+      case # rubocop:disable Style/EmptyCaseCondition Ignore
+      when object.is_a?(Hash)
+        object.inject({}) do |memo, (k, v)| # rubocop:disable Style/EachWithObject Ignore
+          memo[k.to_sym] = symbolise_object(v)
+          memo
+        end
+      when object.is_a?(Array)
+        object.map { |i| symbolise_object(i) }
+      else
+        object
+      end
+    end
+
+    def self.static_ca_cert_file
+      @static_ca_cert_file ||= File.expand_path(File.join(__dir__, 'data', 'ruby_ca_certs.pem'))
+    end
+  end
+end

data/lib/puppetfile-resolver/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module PuppetfileResolver
+  VERSION ||= '0.1.0'
+end

data/puppetfile-cli.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+# This is not supposed to be a fully fledged CLI for the resolver, as this gem is designed to be used
+# as a library. The CLI is offered as an example as to how to use the library.
+
+# Add the resolver into the load path
+lib_root = File.expand_path(File.join(__dir__, 'lib'))
+$LOAD_PATH.unshift(lib_root)
+
+require 'puppetfile-resolver'
+require 'optparse'
+
+class CommandLineParser
+  def self.parse(options)
+    # Set defaults here
+    args = {
+      debug: false,
+      cache_dir: nil,
+      module_paths: [],
+      path: nil,
+      puppet_version: nil,
+      strict: false
+    }
+
+    opt_parser = OptionParser.new do |opts|
+      opts.banner = 'Usage: puppetfile-cli.rb [options]'
+
+      opts.on('-pPATH', '--path=PATH', 'Puppetfile to parse') do |path|
+        args[:path] = path
+      end
+
+      opts.on('-vVERSION', '--puppet_version=VERSION', 'Restrict the resolver to only modules which support the specified Puppet version') do |version|
+        args[:puppet_version] = version
+      end
+
+      opts.on('-cDIR', '--cache_directory=DIR', 'Directory to the persistent on disk cache.  Optional') do |cache_dir|
+        args[:cache_dir] = cache_dir
+      end
+
+      opts.on('--debug', 'Output debug information. Default is no debug output') do
+        args[:debug] = true
+      end
+
+      opts.on('-s', '--strict', 'Do not allow missing dependencies. Default false which marks dependencies as missing and does not raise an error.') do
+        args[:strict] = true
+      end
+
+      opts.on('-mTEXT', '--module_paths=TEXT', Array, 'Comma delimited list of modules paths to search') do |text|
+        args[:module_paths] = text
+      end
+    end
+
+    opt_parser.parse!(options.dup)
+    args
+  end
+end
+
+options = CommandLineParser.parse(ARGV)
+raise 'Missing --path' if options[:path].nil?
+
+# Configure the cache
+if options[:cache_dir].nil?
+  cache = nil
+else
+  require 'puppetfile-resolver/cache/persistent'
+  cache = PuppetfileResolver::Cache::Persistent.new(options[:cache_dir])
+end
+
+# Parse the Puppetfile into an object model
+content = File.open(options[:path], 'rb') { |f| f.read }
+require 'puppetfile-resolver/puppetfile/parser/r10k_eval'
+puppetfile = ::PuppetfileResolver::Puppetfile::Parser::R10KEval.parse(content)
+
+# Make sure the Puppetfile is valid
+unless puppetfile.valid?
+  puts 'Puppetfile is not valid'
+  puppetfile.validation_errors.each { |err| puts err }
+  exit 1
+end
+
+# Create the resolver
+resolver = PuppetfileResolver::Resolver.new(puppetfile, options[:puppet_version])
+
+# Configure the resolver
+if options[:debug]
+  require 'puppetfile-resolver/ui/debug_ui'
+  ui = PuppetfileResolver::UI::DebugUI.new
+else
+  ui = nil
+end
+opts = { cache: cache, ui: ui, module_paths: options[:module_paths], allow_missing_modules: !options[:strict] }
+
+# Resolve
+result = resolver.resolve(opts)
+
+# Output errors
+result.validation_errors.each { |err| puts "Resolution Validation Error: #{err}\n" }
+
+# Output the Graph in a DOT format
+puts "\n--- Dependency Graph"
+puts result.to_dot

data/spec/spec_helper.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+root = File.join(__dir__,'..',)
+# Add the language server into the load path
+$LOAD_PATH.unshift(File.join(root,'lib'))
+
+# A cache which we can preload for the purposes of testing, mimicing
+# Local modules
+require 'puppetfile-resolver/cache/base'
+class MockLocalModuleCache < PuppetfileResolver::Cache::Base
+  def initialize
+    super(nil)
+
+    @mock_modules = {}
+  end
+
+  def exist?(name)
+    result = super
+    return result if result
+    @mock_modules.key?(name)
+  end
+
+  def load(name)
+    result = super
+    return result unless result.nil?
+
+    @mock_modules[name]
+  end
+
+  def add_local_module_spec(name, dependencies = [], puppet_requirement = nil, version = '1.0.0')
+    requirements = []
+    requirements << { name: 'puppet', version_requirement: puppet_requirement } unless puppet_requirement.nil?
+    spec = PuppetfileResolver::Models::ModuleSpecification.new(
+      name: name,
+      origin: :local,
+      version: version,
+      metadata: {
+        dependencies: dependencies,
+        requirements: requirements
+      }
+    )
+    # Note - This is quite implementation dependant so could be fragile.
+    # Yes, I know it's expecting a Dependency object, but the spec is fine.
+    id = PuppetfileResolver::SpecSearchers::Common.dependency_cache_id(PuppetfileResolver::SpecSearchers::Local, spec)
+    @mock_modules[id] = [] if @mock_modules[id].nil?
+    @mock_modules[id] << spec
+  end
+end

data/spec/unit/puppetfile-resolver/puppetfile/document_spec.rb

@@ -0,0 +1,316 @@
+require 'spec_helper'
+
+require 'puppetfile-resolver/models'
+require 'puppetfile-resolver/resolution_result'
+require 'puppetfile-resolver/puppetfile'
+
+describe 'PuppetfileResolver::Puppetfile::Document' do
+  let(:puppetfile_content) { 'puppetfile' }
+  let(:subject) { PuppetfileResolver::Puppetfile::Document.new(puppetfile_content) }
+
+  describe "Document Validation" do
+    context 'Given an empty document' do
+      before(:each) do
+        subject.clear_modules
+      end
+
+      it 'should be valid' do
+        expect(subject.valid?).to eq(true)
+      end
+
+      it 'should have no validation errors' do
+        expect(subject.validation_errors).to eq([])
+      end
+    end
+
+    context 'Given a document with valid modules' do
+      let(:module1) { PuppetfileResolver::Puppetfile::LocalModule.new('foo') }
+      let(:module2) { PuppetfileResolver::Puppetfile::LocalModule.new('bar') }
+      let(:module3) { PuppetfileResolver::Puppetfile::LocalModule.new('baz') }
+
+      before(:each) do
+        subject.clear_modules
+        subject.add_module(module1)
+        subject.add_module(module2)
+        subject.add_module(module3)
+      end
+
+      it 'should be valid' do
+        expect(subject.valid?).to eq(true)
+      end
+
+      it 'should have no validation errors' do
+        expect(subject.validation_errors).to eq([])
+      end
+    end
+
+    context 'Given a document with an invalid module' do
+      let(:invalid_module) do
+        PuppetfileResolver::Puppetfile::InvalidModule.new('foo-invalid').tap { |m| m.reason = 'MockReason' }
+      end
+
+      before(:each) do
+        subject.clear_modules
+        subject.add_module(invalid_module)
+      end
+
+      it 'should not be valid' do
+        expect(subject.valid?).to eq(false)
+      end
+
+      it 'should have a validation error' do
+        expect(subject.validation_errors.count).to eq (1)
+        expect(subject.validation_errors[0]).to be_a(PuppetfileResolver::Puppetfile::DocumentInvalidModuleError)
+        expect(subject.validation_errors[0]).to have_attributes(
+          :message => 'MockReason',
+          :puppet_module => invalid_module
+        )
+      end
+    end
+
+    context 'Given a document with duplicate modules' do
+      let(:module1) { PuppetfileResolver::Puppetfile::LocalModule.new('foo') }
+      let(:module2) { PuppetfileResolver::Puppetfile::LocalModule.new('foo') }
+      let(:module3) { PuppetfileResolver::Puppetfile::LocalModule.new('foo') }
+      let(:module4) { PuppetfileResolver::Puppetfile::LocalModule.new('bar') }
+      let(:module5) { PuppetfileResolver::Puppetfile::LocalModule.new('bar') }
+      let(:module6) { PuppetfileResolver::Puppetfile::LocalModule.new('baz') }
+
+      before(:each) do
+        subject.clear_modules
+        subject.add_module(module1)
+        subject.add_module(module2)
+        subject.add_module(module3)
+        subject.add_module(module4)
+        subject.add_module(module5)
+        subject.add_module(module6)
+      end
+
+      it 'should not be valid' do
+        expect(subject.valid?).to eq(false)
+      end
+
+      it 'should have validation errors' do
+        expect(subject.validation_errors.count).to eq (2)
+        # Duplication foo module
+        err = subject.validation_errors[0]
+        expect(err).to be_a(PuppetfileResolver::Puppetfile::DocumentDuplicateModuleError)
+        expect(err).to have_attributes(
+          :message => /foo/,
+          :puppet_module => module1,
+          :duplicates => [module2, module3]
+        )
+        # Duplicate bar module
+        err = subject.validation_errors[1]
+        expect(err).to be_a(PuppetfileResolver::Puppetfile::DocumentDuplicateModuleError)
+        expect(err).to have_attributes(
+          :message => /bar/,
+          :puppet_module => module4,
+          :duplicates => [module5]
+        )
+      end
+    end
+  end
+
+  describe ".resolution_validation_errors" do
+    # Array of modules to add to the document
+    let(:document_fixtures) { [] }
+    let(:resolution_graph) { Molinillo::DependencyGraph.new }
+    let(:resolution_result) { PuppetfileResolver::ResolutionResult.new(resolution_graph, subject) }
+    let(:resolution_specifications) { [] }
+    let(:resolution_dependencies) { [] }
+
+    before(:each) do
+      # Generate the Puppetfile document
+      subject.clear_modules
+      @document_modules = document_fixtures.map do |doc_mod|
+        mod = doc_mod[:class].new(doc_mod[:name])
+        mod.version = doc_mod[:version]
+        subject.add_module(mod)
+        mod
+      end
+
+      # Generate the Dependency Graph
+      @module_specifications = {}
+      # Create all of the specifications
+      resolution_specifications.each do |res_spec|
+        res_spec[:class] = PuppetfileResolver::Models::ModuleSpecification if res_spec[:class].nil?
+        @module_specifications[res_spec[:name]] = res_spec[:class].new(name: res_spec[:name], origin: res_spec[:origin], metadata: {}, version: res_spec[:version])
+      end
+      # Create all of the vertexes in the graph
+      @module_specifications.each { |name, spec| resolution_graph.add_vertex(name, spec, false) }
+      # Create all of the edges in the graph
+      resolution_dependencies.each do |dep|
+        dep[:class] = PuppetfileResolver::Models::ModuleDependency if dep[:class].nil?
+        mod_dep = dep[:class].new(name: dep[:destination], version_requirement: dep[:version_requirement])
+        resolution_graph.add_edge(
+          resolution_graph.vertex_named(dep[:origin]),
+          resolution_graph.vertex_named(dep[:destination]),
+          mod_dep
+        )
+      end
+    end
+
+    context 'Given an invalid document' do
+      before(:each) do
+        allow(subject).to receive(:valid?).and_return(false)
+      end
+
+      it 'should raise' do
+        expect{ subject.resolution_validation_errors(resolution_result) }.to raise_error(/invalid document/)
+      end
+    end
+
+    context 'Given a valid resolution' do
+      let(:document_fixtures) do
+        [
+          { class: PuppetfileResolver::Puppetfile::LocalModule, name: 'foo' },
+          { class: PuppetfileResolver::Puppetfile::LocalModule, name: 'bar' }
+        ]
+      end
+      let(:resolution_specifications) do
+        [
+          { name: 'foo', origin: :local, version: '1.0.0' },
+          { name: 'bar', origin: :local, version: '1.0.0' }
+        ]
+      end
+      let(:resolution_dependencies) do
+        [
+          { origin: 'foo', destination: 'bar', version_requirement: '>= 0' },
+        ]
+      end
+      it 'should return no errors' do
+        expect(subject.resolution_validation_errors(resolution_result)).to be_empty
+      end
+    end
+
+    context 'Given a document with :latest' do
+      let(:document_fixtures) do
+        [
+          { class: PuppetfileResolver::Puppetfile::ForgeModule, name: 'foo', version: :latest }
+        ]
+      end
+      let(:resolution_specifications) do
+        [
+          { name: 'foo', origin: :forge, version: '1.0.0' }
+        ]
+      end
+
+      it 'should return a DocumentLatestVersionError' do
+        errors = subject.resolution_validation_errors(resolution_result)
+        expect(errors.count).to eq(1)
+        error = errors[0]
+        expect(error).to be_a(PuppetfileResolver::Puppetfile::DocumentLatestVersionError)
+        expect(error).to have_attributes(
+          message: /foo/,
+          module_specification: @module_specifications['foo'],
+          puppet_module: @document_modules[0]
+        )
+      end
+    end
+
+    context 'Given a document with a missing module' do
+      let(:document_fixtures) do
+        [
+          { class: PuppetfileResolver::Puppetfile::LocalModule, name: 'foo', version: :latest }
+        ]
+      end
+      let(:resolution_specifications) do
+        [
+          { class: PuppetfileResolver::Models::MissingModuleSpecification, name: 'foo' }
+        ]
+      end
+
+      it 'should return a DocumentMissingModuleError' do
+        errors = subject.resolution_validation_errors(resolution_result)
+        expect(errors.count).to eq(1)
+        error = errors[0]
+        expect(error).to be_a(PuppetfileResolver::Puppetfile::DocumentMissingModuleError)
+        expect(error).to have_attributes(
+          message: /foo/,
+          module_specification: @module_specifications['foo'],
+          puppet_module: @document_modules[0]
+        )
+      end
+    end
+
+    context 'Given a document with missing module dependencies' do
+      # We setup a Puppetfile that looks like
+      # ```
+      # mod 'foo', :local => true
+      # mod 'baz', :local => true
+      # mod 'waldo', :local => true
+      # ```
+      let(:document_fixtures) do
+        [
+          { class: PuppetfileResolver::Puppetfile::LocalModule, name: 'foo',   version: '1.0.0' },
+          { class: PuppetfileResolver::Puppetfile::LocalModule, name: 'baz',   version: '1.0.0' },
+          { class: PuppetfileResolver::Puppetfile::LocalModule, name: 'waldo', version: '1.0.0' },
+        ]
+      end
+      # We then setup a resolution graph that looks like
+      #
+      #   foo --> bar --> baz --> qux
+      #            waldo --^
+      #
+      # Where foo depends on bar, which depends on baz, which depends on qux. And
+      # waldo depends on baz, which depends on qux
+      #
+      # Due to the puppetfile and dependency graph:
+      # - foo will be missing bar and qux
+      # - baz will be missing qux
+      # - waldo will be missing qux
+      #
+      # This is to test for transitive dependencies, not just an entire dependency tree
+      let(:resolution_specifications) do
+        [
+          { name: 'foo',   origin: :forge, version: '1.0.0' },
+          { name: 'bar',   origin: :forge, version: '1.0.0' },
+          { name: 'baz',   origin: :forge, version: '1.0.0' },
+          { name: 'qux',   origin: :forge, version: '1.0.0' },
+          { name: 'waldo', origin: :forge, version: '1.0.0' },
+        ]
+      end
+      let(:resolution_dependencies) do
+        [
+          { origin: 'foo',   destination: 'bar',  version_requirement: '>= 0' },
+          { origin: 'bar',   destination: 'baz',  version_requirement: '>= 0' },
+          { origin: 'baz',   destination: 'qux',  version_requirement: '>= 0' },
+          { origin: 'waldo',  destination: 'baz', version_requirement: '>= 0' },
+        ]
+      end
+
+      it 'should return transient DocumentMissingModuleError' do
+        errors = subject.resolution_validation_errors(resolution_result)
+        expect(errors.count).to eq(3)
+
+        error = errors[0]
+        expect(error).to be_a(PuppetfileResolver::Puppetfile::DocumentMissingDependenciesError)
+        expect(error).to have_attributes(
+          message:                /foo/,
+          module_specification:   @module_specifications['foo'],
+          puppet_module:          @document_modules[0],
+          missing_specifications: [@module_specifications['bar'], @module_specifications['qux']]
+        )
+
+        error = errors[1]
+        expect(error).to be_a(PuppetfileResolver::Puppetfile::DocumentMissingDependenciesError)
+        expect(error).to have_attributes(
+          message:                /baz/,
+          module_specification:   @module_specifications['baz'],
+          puppet_module:          @document_modules[1],
+          missing_specifications: [@module_specifications['qux']]
+        )
+
+        error = errors[2]
+        expect(error).to be_a(PuppetfileResolver::Puppetfile::DocumentMissingDependenciesError)
+        expect(error).to have_attributes(
+          message:                /waldo/,
+          module_specification:   @module_specifications['waldo'],
+          puppet_module:          @document_modules[2],
+          missing_specifications: [@module_specifications['qux']]
+        )
+      end
+    end
+  end
+end