berkshelf 3.0.0.beta1 → 3.0.0.beta2

data/features/show_command.feature

@@ -12,6 +12,16 @@ Feature: Displaying information about a cookbook defined by a Berksfile
 
       cookbook 'fake', '1.0.0'
       """
+    And I write to "Berksfile.lock" with:
+      """
+      {
+        "dependencies": {
+          "fake": {
+            "locked_version": "1.0.0"
+          }
+        }
+      }
+      """
     When I successfully run `berks show fake`
     Then the output should contain:
       """
@@ -23,43 +33,52 @@ Feature: Displaying information about a cookbook defined by a Berksfile
            License: none
       """
 
-  Scenario: When JSON is requested
-    Given the cookbook store has the cookbooks:
-      | fake | 1.0.0 |
+  Scenario: When the cookbook is not in the Berksfile
+    Given I write to "Berksfile" with:
+      """
+      source "http://localhost:26210"
+      """
+    When I run `berks show fake`
+    Then the output should contain:
+      """
+      Could not find cookbook(s) 'fake' in any of the configured dependencies. Is it in your Berksfile?
+      """
+    And the exit status should be "DependencyNotFound"
+
+  Scenario: When there is no lockfile present
     And I write to "Berksfile" with:
       """
       source "http://localhost:26210"
 
       cookbook 'fake', '1.0.0'
       """
-    When I successfully run `berks show fake --format json`
+    When I run `berks show fake`
     Then the output should contain:
       """
-      {
-        "cookbooks": [
-          {
-            "name": "fake",
-            "version": "1.0.0",
-            "description": "A fabulous new cookbook",
-            "author": "YOUR_COMPANY_NAME",
-            "email": "YOUR_EMAIL",
-            "license": "none"
-          }
-        ],
-        "errors": [
-
-        ],
-        "messages": [
-          "building universe..."
-        ]
-      }
+      Could not find cookbook 'fake (>= 0.0.0)'. Try running `berks install` to download and install the missing dependencies.
       """
+    And the exit status should be "LockfileNotFound"
 
-  Scenario: When the cookbook is not in the Berksfile
-    Given I write to "Berksfile" with:
+  Scenario: When the cookbook is not installed
+    And I write to "Berksfile" with:
       """
       source "http://localhost:26210"
+
+      cookbook 'fake', '1.0.0'
+      """
+    And I write to "Berksfile.lock" with:
+      """
+      {
+        "dependencies": {
+          "fake": {
+            "locked_version": "1.0.0"
+          }
+        }
+      }
       """
     When I run `berks show fake`
-    Then the output should contain "Cookbook 'fake' is not installed by your Berksfile"
+    Then the output should contain:
+      """
+      Could not find cookbook 'fake (= 1.0.0)'. Try running `berks install` to download and install the missing dependencies.
+      """
     And the exit status should be "CookbookNotFound"

data/features/step_definitions/chef/config_steps.rb

@@ -4,8 +4,8 @@ end
 
 Given /^I do not have a Chef config$/ do
 	path = tmp_path.join('knife.rb').to_s
-  Berkshelf.chef_config = Berkshelf::Chef::Config.new(path)
-  Berkshelf::Chef::Config.instance.save
+  Berkshelf.chef_config = Ridley::Chef::Config.new(path)
+  Berkshelf.chef_config.save
 
   ENV['BERKSHELF_CHEF_CONFIG'] = path
   set_env 'BERKSHELF_CHEF_CONFIG', path

data/features/step_definitions/chef_server_steps.rb

@@ -8,10 +8,18 @@ Given /^the Chef Server has cookbooks:$/ do |cookbooks|
   cookbooks.raw.each do |name, version|
     purge_cookbook(name, version)
     cb_path = generate_cookbook(tmp_path, name, version)
-    upload_cookbook(cb_path)
+    upload_cookbook(cb_path, freeze: false, force: true)
   end
 end
 
+Given /^the Chef Server has frozen cookbooks:$/ do |cookbooks|
+  cookbooks.raw.each do |name, version|
+    purge_cookbook(name, version)
+    cb_path = generate_cookbook(tmp_path, name, version)
+    upload_cookbook(cb_path, freeze: true, force: true)
+  end
+ end
+
 Then /^the Chef Server should have the cookbooks:$/ do |cookbooks|
   cookbooks.raw.each do |name, version|
     expect(server_has_cookbook?(name, version)).to be_true

data/features/step_definitions/config_steps.rb

@@ -34,7 +34,7 @@ end
 Then /^a Berkshelf config file should exist at "(.+)" and contain:$/ do |path, table|
   check_file_presence([path], true)
 
-  path = File.expand_path(File.join('tmp', 'aruba', path))
+  path             = File.join(@dirs.first, path)
   Berkshelf.config = Berkshelf::Config.from_file(path)
 
   table.raw.each do |key, value|

data/features/step_definitions/filesystem_steps.rb

@@ -250,3 +250,10 @@ Then /^the file "(.*?)" in the directory "(.*?)" should not contain:$/ do |file_
     end
   }
 end
+
+Then(/^the directory "(.*?)" should contain version "(.*?)" of the "(.*?)" cookbook$/) do |path, version, name|
+  cookbook_path = File.join(current_dir, path)
+  cookbook = Berkshelf::CachedCookbook.from_path(cookbook_path)
+  expect(cookbook.version).to eql(version)
+  expect(cookbook.cookbook_name).to eql(name)
+end

data/features/support/env.rb

@@ -29,6 +29,7 @@ Spork.prefork do
 
     Aruba::InProcess.main_class = Berkshelf::Cli::Runner
     Aruba.process               = Aruba::InProcess
+    @dirs                       = ["spec/tmp/aruba"] # set aruba's temporary directory
 
     stub_kitchen!
     clean_tmp_path
@@ -42,7 +43,7 @@ Spork.prefork do
         options: {
           url: "http://localhost:#{CHEF_SERVER_PORT}",
           client_name: "reset",
-          client_key: fixtures_path.join("reset.pem")
+          client_key: File.expand_path("spec/config/berkshelf.pem")
         }
       }
     ]

data/features/update_command.feature

@@ -23,8 +23,7 @@ Feature: Updating a cookbook defined by a Berksfile
       {
         "dependencies":{
           "berkshelf-cookbook-fixture":{
-            "locked_version":"0.1.0",
-            "constraint":"~> 0.1"
+            "locked_version":"0.1.0"
           }
         }
       }
@@ -47,12 +46,10 @@ Feature: Updating a cookbook defined by a Berksfile
       {
         "dependencies":{
           "berkshelf-cookbook-fixture":{
-            "locked_version":"0.1.0",
-            "constraint":"~> 0.1"
+            "locked_version":"0.1.0"
           },
           "hostsfile":{
-            "locked_version":"1.0.1",
-            "constraint":"= 1.0.1"
+            "locked_version":"1.0.1"
           }
         }
       }
@@ -63,12 +60,10 @@ Feature: Updating a cookbook defined by a Berksfile
       {
         "dependencies":{
           "berkshelf-cookbook-fixture":{
-            "locked_version":"0.2.0",
-            "constraint":"~> 0.1"
+            "locked_version":"0.2.0"
           },
           "hostsfile":{
-            "locked_version":"1.0.1",
-            "constraint":"~> 1.0.0"
+            "locked_version":"1.0.1"
           }
         }
       }
@@ -91,12 +86,10 @@ Feature: Updating a cookbook defined by a Berksfile
       {
         "dependencies":{
           "berkshelf-cookbook-fixture":{
-            "locked_version":"0.1.0",
-            "constraint":"~> 0.1"
+            "locked_version":"0.1.0"
           },
           "hostsfile":{
-            "locked_version":"1.0.0",
-            "constraint":"~> 1.0.0"
+            "locked_version":"1.0.1"
           }
         }
       }
@@ -107,12 +100,10 @@ Feature: Updating a cookbook defined by a Berksfile
       {
         "dependencies":{
           "berkshelf-cookbook-fixture":{
-            "locked_version":"0.2.0",
-            "constraint":"~> 0.1"
+            "locked_version":"0.2.0"
           },
           "hostsfile":{
-            "locked_version":"1.0.0",
-            "constraint":"~> 1.0.0"
+            "locked_version":"1.0.1"
           }
         }
       }
@@ -132,8 +123,7 @@ Feature: Updating a cookbook defined by a Berksfile
       {
         "dependencies":{
           "berkshelf-cookbook-fixture":{
-            "locked_version":"0.1.0",
-            "constraint":"~> 0.1"
+            "locked_version":"0.1.0"
           }
         }
       }
@@ -143,4 +133,4 @@ Feature: Updating a cookbook defined by a Berksfile
       """
       Could not find cookbook(s) 'non-existent-cookbook' in any of the configured dependencies. Is it in your Berksfile?
       """
-    And the exit status should be "CookbookNotFound"
+    And the exit status should be "DependencyNotFound"

data/features/upload_command.feature

@@ -100,7 +100,7 @@ Feature: Uploading cookbooks to a Chef Server
     When I run `berks upload reset`
     Then the output should contain:
       """
-      Failed to upload cookbook 'reset'. Not defined in Berksfile.
+      Could not find cookbook(s) 'reset' in any of the configured dependencies. Is it in your Berksfile?
       """
     And the exit status should be "DependencyNotFound"
 
@@ -281,3 +281,47 @@ Feature: Uploading cookbooks to a Chef Server
       """
       Uploading fake (0.0.0)
       """
+
+  Scenario: When the cookbook already exist
+    Given the cookbook store has the cookbooks:
+      | fake  | 1.0.0 |
+    And the Chef Server has frozen cookbooks:
+      | fake  | 1.0.0 |
+    And I write to "Berksfile" with:
+      """
+      cookbook 'fake', '1.0.0'
+      """
+    When I successfully run `berks upload`
+    Then the output should contain:
+      """
+      Skipping fake (1.0.0) (already uploaded)
+      """
+    And the output should contain:
+      """
+      Skipped uploading some cookbooks because they already existed on the remote server. Re-run with the `--force` flag to force overwrite these cookbooks:
+
+        * fake (1.0.0)
+      """
+    And the exit status should be 0
+
+  Scenario: When the cookbook already exist and is a metadata location
+    Given a cookbook named "fake"
+    And the cookbook "fake" has the file "Berksfile" with:
+      """
+      metadata
+      """
+    When I cd to "fake"
+    And the Chef Server has frozen cookbooks:
+      | fake  | 0.0.0 |
+    When I run `berks upload`
+    Then the output should contain:
+      """
+      building universe...
+      Using fake (0.0.0) path: '/home/travis/build/RiotGames/berkshelf/spec/tmp/aruba/fake'
+      Uploading fake (0.0.0) to: 'http://localhost:26310/'
+      Skipping fake (0.0.0) (already uploaded)
+      Skipped uploading some cookbooks because they already existed on the remote server. Re-run with the `--force` flag to force overwrite these cookbooks:
+      
+        * fake (0.0.0)
+      """
+    And the exit status should be 0

data/features/vendor_command.feature

@@ -0,0 +1,83 @@
+Feature: Vendoring cookbooks to a directory
+  As a CLI user
+  I want a command to vendor cookbooks into a directory
+  So they are structured similar to a Chef Repository
+
+  Background:
+    Given the Berkshelf API server's cache is empty
+    And the Chef Server is empty
+
+  Scenario: successfully vendoring a Berksfile with multiple cookbook demands
+    Given I write to "Berksfile" with:
+      """
+      source "http://localhost:26210"
+
+      cookbook 'berkshelf'
+      cookbook 'elixir'
+      """
+    And the Chef Server has cookbooks:
+      | berkshelf | 1.0.0 |
+      | elixir    | 1.0.0 |
+    And the Berkshelf API server's cache is up to date
+    When I successfully run `berks vendor cukebooks`
+    Then the output should contain:
+      """
+      Vendoring berkshelf (1.0.0) to
+      """
+    And the output should contain:
+      """
+      Vendoring elixir (1.0.0) to
+      """
+    And a directory named "cukebooks/berkshelf" should exist
+    And a directory named "cukebooks/elixir" should exist
+    And the directory "cukebooks/berkshelf" should contain version "1.0.0" of the "berkshelf" cookbook
+    And the directory "cukebooks/elixir" should contain version "1.0.0" of the "elixir" cookbook
+
+  Scenario: attempting to vendor when no Berksfile is present
+    When I run `berks vendor cukebooks`
+    Then the exit status should be "BerksfileNotFound"
+
+  Scenario: vendoring a Berksfile with a metadata demand
+    Given a cookbook named "sparkle-motion"
+    And the cookbook "sparkle-motion" has the file "Berksfile" with:
+      """
+      source "http://localhost:26210"
+
+      metadata
+      """
+    When I cd to "sparkle-motion"
+    And I successfully run `berks vendor cukebooks`
+    Then the output should contain:
+      """
+      Vendoring sparkle-motion (0.0.0) to
+      """
+    And a directory named "cukebooks/sparkle-motion" should exist
+    And the directory "cukebooks/sparkle-motion" should contain version "0.0.0" of the "sparkle-motion" cookbook
+
+  Scenario: vendoring without an explicit path to vendor into
+    Given I write to "Berksfile" with:
+      """
+      source "http://localhost:26210"
+
+      cookbook 'berkshelf'
+      """
+    And the Chef Server has cookbooks:
+      | berkshelf | 1.0.0 |
+    And the Berkshelf API server's cache is up to date
+    When I successfully run `berks vendor`
+    And a directory named "berks-cookbooks/berkshelf" should exist
+    And the directory "berks-cookbooks/berkshelf" should contain version "1.0.0" of the "berkshelf" cookbook
+
+  Scenario: vendoring to a directory that already exists
+    Given I write to "Berksfile" with:
+      """
+      source "http://localhost:26210"
+
+      cookbook 'berkshelf'
+      """
+    And the Chef Server has cookbooks:
+      | berkshelf | 1.0.0 |
+    And the Berkshelf API server's cache is up to date
+    And a directory named "cukebooks"
+    When I run `berks vendor cukebooks`
+    And the exit status should be "VendorError"

data/lib/berkshelf.rb

@@ -67,14 +67,14 @@ module Berkshelf
 
     # The Chef configuration file.
     #
-    # @return [Berkshelf::Chef::Config]
+    # @return [Ridley::Chef::Config]
     def chef_config
-      Berkshelf::Chef::Config.instance
+      @chef_config ||= Ridley::Chef::Config.new(ENV['BERKSHELF_CHEF_CONFIG'])
     end
 
-    # @param [Berkshelf::Chef::Config]
+    # @param [Ridley::Chef::Config]
     def chef_config=(config)
-      Berkshelf::Chef::Config.set_config(config)
+      @chef_config = config
     end
 
     # Initialize the filepath for the Berkshelf path..
@@ -153,6 +153,7 @@ require_relative 'berkshelf/dependency'
 require_relative 'berkshelf/downloader'
 require_relative 'berkshelf/formatters'
 require_relative 'berkshelf/git'
+require_relative 'berkshelf/mercurial'
 require_relative 'berkshelf/init_generator'
 require_relative 'berkshelf/installer'
 require_relative 'berkshelf/location'

data/lib/berkshelf/api_client/remote_cookbook.rb

@@ -1,3 +1,5 @@
+require 'json'
+
 module Berkshelf
   class APIClient
     # A representation of cookbook metadata indexed by a Berkshelf API Server. Returned
@@ -37,6 +39,17 @@ module Berkshelf
       def location_path
         @attributes[:location_path]
       end
+
+      def to_hash
+        {
+          name: name,
+          version: version
+        }
+      end
+
+      def to_json(options = {})
+        ::JSON.pretty_generate(to_hash, options)
+      end
     end
   end
 end

data/lib/berkshelf/berksfile.rb

@@ -13,11 +13,13 @@ module Berkshelf
       #
       # @return [Berksfile]
       def from_file(file)
-        new(file).dsl_eval_file(file)
-      rescue Errno::ENOENT => ex
-        raise BerksfileNotFound, "No Berksfile or Berksfile.lock found at: #{file}"
-      rescue => ex
-        raise BerksfileReadError.new(ex)
+        raise BerksfileNotFound.new(file) unless File.exist?(file)
+
+        begin
+          new(file).dsl_eval_file(file)
+        rescue => ex
+          raise BerksfileReadError.new(ex)
+        end
       end
     end
 
@@ -365,6 +367,40 @@ module Berkshelf
       self.install
     end
 
+    # Retrieve information about a given cookbook that is installed by this Berksfile.
+    # Unlike {#find}, which returns a dependency, this method returns the corresponding
+    # CachedCookbook for the given name.
+    #
+    # @raise [LockfileNotFound]
+    #   if there is no lockfile containing that cookbook
+    # @raise [CookbookNotFound]
+    #   if there is a lockfile with a cookbook, but the cookbook is not downloaded
+    #
+    # @param [String] name
+    #   the name of the cookbook to find
+    #
+    # @return [CachedCookbook]
+    #   the CachedCookbook that corresponds to the given name parameter
+    def retrieve_locked(name)
+      validate_cookbook_names!(cookbooks: name)
+
+      locked = lockfile.find(name)
+      unless locked
+        raise LockfileNotFound, "Could not find cookbook '#{name} (>= 0.0.0)'."\
+          " Try running `berks install` to download and install the missing"\
+          " dependencies."
+      end
+
+      cookbook = locked.cached_cookbook
+      unless cookbook
+        raise CookbookNotFound, "Could not find cookbook '#{name} (= #{locked.locked_version})'."\
+          " Try running `berks install` to download and install the missing"\
+          " dependencies."
+      end
+
+      cookbook
+    end
+
     # List of all the cookbooks which have a newer version found at a source that satisfies
     # the constraints of your dependencies
     #
@@ -386,7 +422,28 @@ module Berkshelf
     #     #<CachedCookbook name="artifact"> => "0.11.2"
     #   }
     def outdated(options = {})
-      raise RuntimeError, "not yet implemented"
+      validate_cookbook_names!(options)
+
+      outdated = {}
+      dependencies(options).each do |dependency|
+        locked = retrieve_locked(dependency.name)
+        outdated[dependency.name] = {}
+
+        sources.each do |source|
+          cookbooks = source.versions(dependency.name)
+
+          latest = cookbooks.select do |cookbook|
+            dependency.version_constraint.satisfies?(cookbook.version) &&
+            cookbook.version != locked.version
+          end.sort_by { |cookbook| cookbook.version }.last
+
+          unless latest.nil?
+            outdated[dependency.name][source.uri.to_s] = latest
+          end
+        end
+      end
+
+      outdated.reject { |name, newer| newer.empty? }
     end
 
     # Upload the cookbooks installed by this Berksfile
@@ -417,16 +474,19 @@ module Berkshelf
     # @raise [Berkshelf::DependencyNotFound]
     #   if one of the given cookbooks is not a dependency defined in the Berksfile
     # @raise [Berkshelf::FrozenCookbook]
-    #   if an attempt to upload a cookbook which has been frozen on the target server is made
-    #   and the :halt_on_frozen option was true
+    #   if the cookbook being uploaded is a {metadata} cookbook and is already
+    #   frozen on the remote Chef Server; indirect dependencies or non-metadata
+    #   dependencies are just skipped
     def upload(options = {})
-      options = options.reverse_merge(force: false, freeze: true, halt_on_frozen: false, cookbooks: [])
+      options = {
+        force: false,
+        freeze: true,
+        halt_on_frozen: false,
+        skip_dependencies: false,
+        cookbooks: [],
+      }.merge(options)
 
-      options[:cookbooks].each do |cookbook|
-        unless dependency = find(cookbook)
-          raise DependencyNotFound, "Failed to upload cookbook '#{cookbook}'. Not defined in Berksfile."
-        end
-      end
+      validate_cookbook_names!(options)
 
       cached_cookbooks = install(options)
       cached_cookbooks = filter_to_upload(cached_cookbooks, options[:cookbooks]) if options[:cookbooks]
@@ -495,9 +555,12 @@ module Berkshelf
       cached_cookbooks.each { |cookbook| validate_files!(cookbook) }
 
       Dir.mktmpdir do |tmp|
+        cookbooks_dir = File.join(tmp, 'cookbooks')
+        FileUtils.mkdir_p(cookbooks_dir)
+
         cached_cookbooks.each do |cookbook|
           path        = cookbook.path.to_s
-          destination = File.join(tmp, cookbook.cookbook_name)
+          destination = File.join(cookbooks_dir, cookbook.cookbook_name)
 
           FileUtils.cp_r(path, destination)
 
@@ -522,6 +585,61 @@ module Berkshelf
       output
     end
 
+    # Install the Berksfile or Berksfile.lock and then copy the cached cookbooks into
+    # directories within the given destination matching their name.
+    #
+    # @param [String] destination
+    #   filepath to vendor cookbooks to
+    #
+    # @option options [Symbol, Array] :except
+    #   Group(s) to exclude which will cause any dependencies marked as a member of the
+    #   group to not be installed
+    # @option options [Symbol, Array] :only
+    #   Group(s) to include which will cause any dependencies marked as a member of the
+    #   group to be installed and all others to be ignored
+    #
+    # @return [String, nil]
+    #   the expanded path cookbooks were vendored to or nil if nothing was vendored
+    def vendor(destination, options = {})
+      destination = File.expand_path(destination)
+
+      if Dir.exist?(destination)
+        raise VendorError, "destination already exists #{destination}. Delete it and try again or use a " +
+          "different filepath."
+      end
+
+      scratch          = Berkshelf.mktmpdir
+      chefignore       = nil
+      cached_cookbooks = install(options.slice(:except, :only))
+
+      if cached_cookbooks.empty?
+        return nil
+      end
+
+      if ignore_file = Berkshelf::Chef::Cookbook::Chefignore.find_relative_to(Dir.pwd)
+        chefignore = Berkshelf::Chef::Cookbook::Chefignore.new(ignore_file)
+      end
+
+      cached_cookbooks.each do |cookbook|
+        Berkshelf.formatter.vendor(cookbook, destination)
+        cookbook_destination = File.join(scratch, cookbook.cookbook_name, '/')
+        FileUtils.mkdir_p(cookbook_destination)
+
+        # Dir.glob does not support backslash as a File separator
+        src   = cookbook.path.to_s.gsub('\\', '/')
+        files = Dir.glob(File.join(src, '*'))
+
+        if chefignore
+          files = chefignore.remove_ignores_from(files)
+        end
+
+        FileUtils.cp_r(files, cookbook_destination)
+      end
+
+      FileUtils.mv(scratch, destination)
+      destination
+    end
+
     # Get the lockfile corresponding to this Berksfile. This is necessary because
     # the user can specify a different path to the Berksfile. So assuming the lockfile
     # is named "Berksfile.lock" is a poor assumption.
@@ -536,22 +654,37 @@ module Berkshelf
     private
 
       def do_upload(cookbooks, options = {})
-        upload_opts = options.slice(:force, :freeze)
+        @skipped = []
 
         ridley_connection(options) do |conn|
           cookbooks.each do |cookbook|
-            Berkshelf.formatter.upload(cookbook.cookbook_name, cookbook.version, conn.server_url)
+            Berkshelf.formatter.upload(cookbook, conn)
             validate_files!(cookbook)
 
             begin
-              conn.cookbook.upload(cookbook.path, upload_opts.merge(name: cookbook.cookbook_name))
+              conn.cookbook.upload(cookbook.path, {
+                force: options[:force],
+                freeze: options[:freeze],
+                name: cookbook.cookbook_name,
+              })
             rescue Ridley::Errors::FrozenCookbook => ex
               if options[:halt_on_frozen]
-                raise Berkshelf::FrozenCookbook, ex
+                raise Berkshelf::FrozenCookbook.new(cookbook)
               end
+
+              Berkshelf.formatter.skip(cookbook, conn)
+              @skipped << cookbook
             end
           end
         end
+
+        unless @skipped.empty?
+          Berkshelf.formatter.msg "Skipped uploading some cookbooks because they" <<
+            " already existed on the remote server. Re-run with the `--force`" <<
+            " flag to force overwrite these cookbooks:" <<
+            "\n\n" <<
+            "  * " << @skipped.map { |c| "#{c.cookbook_name} (#{c.version})" }.join("\n  * ")
+        end
       end
 
       # Filter the cookbooks to upload based on a set of given names. The dependencies of a cookbook
@@ -608,14 +741,13 @@ module Berkshelf
       # @option options [Array<String>] :cookbooks
       #   a list of strings of cookbook names
       #
-      # @raise [Berkshelf::CookbookNotFound]
+      # @raise [Berkshelf::DependencyNotFound]
       #   if a cookbook name is given that does not exist
       def validate_cookbook_names!(options = {})
         missing = (Array(options[:cookbooks]) - dependencies.map(&:name))
+
         unless missing.empty?
-          raise Berkshelf::CookbookNotFound,
-            "Could not find cookbook(s) #{missing.collect{ |c| "'#{c}'" }.join(', ')} " +
-            "in any of the configured dependencies. #{missing.size == 1 ? 'Is it' : 'Are they' } in your Berksfile?"
+          raise Berkshelf::DependencyNotFound.new(missing)
         end
       end