berkshelf 1.4.6 → 2.0.0.beta

data/lib/berkshelf/resolver.rb

@@ -5,6 +5,7 @@ module Berkshelf
 
     # @return [Berkshelf::Berksfile]
     attr_reader :berksfile
+
     # @return [Solve::Graph]
     attr_reader :graph
 
@@ -14,7 +15,7 @@ module Berkshelf
     # @option options [Array<CookbookSource>, CookbookSource] sources
     def initialize(berksfile, options = {})
       @berksfile  = berksfile
-      @downloader = @berksfile.downloader
+      @downloader = berksfile.downloader
       @graph      = Solve::Graph.new
       @sources    = Hash.new
 

data/lib/berkshelf/ui.rb

@@ -10,16 +10,12 @@ module Berkshelf
       @mute = false
     end
 
-    def say(message = '', color = nil, force_new_line = (message.to_s !~ /( |\t)\Z/))
+    def say(message = "", color = nil, force_new_line = nil)
       return if quiet?
 
-      super(message, color, force_new_line)
-    end
-
-    # @see {say}
-    def info(message = '', color = nil, force_new_line = (message.to_s !~ /( |\t)\Z/))
-      say(message, color, force_new_line)
+      super(message, color)
     end
+    alias_method :info, :say
 
     def say_status(status, message, log_status = true)
       return if quiet?
@@ -29,7 +25,7 @@ module Berkshelf
 
     def warn(message, color = :yellow)
       return if quiet?
-
+      
       say(message, color)
     end
 

data/lib/berkshelf/version.rb

@@ -1,3 +1,3 @@
 module Berkshelf
-  VERSION = "1.4.6"
+  VERSION = "2.0.0.beta"
 end

data/lib/thor/monkies/shell.rb

@@ -1,8 +1,5 @@
 require 'berkshelf/ui'
 
 # @author Seth Vargo <sethvargo@gmail.com>
-class ::Thor::Shell::Color
-  # Include the Berkshelf UI methods - this is used by both
-  # Vagrant and Berkshelf UI
-  include ::Berkshelf::UI
-end
+# Include the Berkshelf UI methods - this is used by both Vagrant and Berkshelf
+Thor::Base.shell.send(:include, Berkshelf::UI)

data/spec/fixtures/cookbooks/example_cookbook/.gitignore

@@ -0,0 +1,2 @@
+.kitchen/
+.kitchen.local.yml

data/spec/fixtures/cookbooks/example_cookbook/.kitchen.yml

@@ -0,0 +1,26 @@
+---
+driver_plugin: vagrant
+
+platforms:
+- name: ubuntu-12.04
+  driver_config:
+    box: canonical-ubuntu-12.04
+    box_url: http://cloud-images.ubuntu.com/vagrant/precise/current/precise-server-cloudimg-amd64-vagrant-disk1.box
+    require_chef_omnibus: true
+- name: ubuntu-10.04
+  driver_config:
+    box: opscode-ubuntu-10.04
+    box_url: http://opscode-vm.s3.amazonaws.com/vagrant/opscode_ubuntu-10.04_chef-11.2.0.box
+- name: centos-6.3
+  driver_config:
+    box: opscode-centos-6.3
+    box_url: http://opscode-vm.s3.amazonaws.com/vagrant/opscode_centos-6.3_chef-11.2.0.box
+- name: centos-5.8
+  driver_config:
+    box: opscode-centos-5.8
+    box_url: http://opscode-vm.s3.amazonaws.com/vagrant/opscode_centos-5.8_chef-11.2.0.box
+
+suites:
+- name: default
+  run_list: []
+  attributes: {}

data/spec/fixtures/cookbooks/example_cookbook/Berksfile.lock

@@ -0,0 +1,5 @@
+{
+  "sha": null,
+  "sources": {
+  }
+}

data/spec/fixtures/lockfiles/default.lock

@@ -0,0 +1,11 @@
+{
+  "sha":"6b76225554cc1f7c0aea0f8b3f10c6743aeba67e",
+  "sources":{
+    "build-essential":{
+      "locked_version":"1.1.2"
+    },
+    "chef-client":{
+      "locked_version":"2.1.4"
+    }
+  }
+}

data/spec/{config/knife.rb → knife.rb.sample}

@@ -4,8 +4,8 @@ log_level                :info
 log_location             STDOUT
 node_name                "berkshelf"
 client_key               "#{current_dir}/berkshelf.pem"
-validation_client_name   "validator"
-validation_key           "#{current_dir}/validator.pem"
+validation_client_name   "chef-validator"
+validation_key           "#{current_dir}/chef-validator.pem"
 chef_server_url          "http://localhost:4000"
 cache_type               'BasicFile'
 cache_options( :path => "#{ENV['HOME']}/.chef/checksums" )

data/spec/spec_helper.rb

@@ -15,7 +15,7 @@ Spork.prefork do
 
   APP_ROOT = File.expand_path('../../', __FILE__)
   ENV["BERKSHELF_PATH"] = File.join(APP_ROOT, "spec", "tmp", "berkshelf")
-  ENV["BERKSHELF_CHEF_CONFIG"] = File.join(APP_ROOT, "spec", "config", "knife.rb")
+  ENV["BERKSHELF_CHEF_CONFIG"] = File.join(APP_ROOT, "spec", "knife.rb")
 
   Dir[File.join(APP_ROOT, "spec/support/**/*.rb")].each {|f| require f}
 
@@ -24,30 +24,40 @@ Spork.prefork do
     config.cassette_library_dir = 'spec/fixtures/cassettes'
     config.hook_into :webmock
     config.default_cassette_options = { record: :new_episodes }
+    config.ignore_localhost = true
   end
 
   RSpec.configure do |config|
     config.include Berkshelf::RSpec::FileSystemMatchers
     config.include JsonSpec::Helpers
     config.include Berkshelf::RSpec::ChefAPI
+    config.include Berkshelf::RSpec::ChefServer
+
+    # Disallow should syntax
+    config.expect_with :rspec do |c|
+      c.syntax = :expect
+    end
 
     config.mock_with :rspec
     config.treat_symbols_as_metadata_keys_with_true_values = true
     config.filter_run focus: true
     config.run_all_when_everything_filtered = true
 
-    config.before(:suite) do
+    config.before(:all) do
       Berkshelf::RSpec::ChefServer.start
       WebMock.disable_net_connect!(allow_localhost: true, net_http_connect_on_start: true)
     end
 
-    config.after(:suite) do
+    config.after(:all) do
       Berkshelf::RSpec::ChefServer.stop
     end
 
     config.before(:each) do
+      Celluloid.shutdown
+      Celluloid.boot
       clean_tmp_path
       Berkshelf.cookbook_store = Berkshelf::CookbookStore.new(tmp_path.join("downloader_tmp"))
+      Berkshelf.set_format(:null)
       Berkshelf.ui.mute!
     end
 
@@ -164,6 +174,8 @@ Spork.prefork do
   def run(cmd)
     `#{cmd}`
   end
+
+  Berkshelf::RSpec::Knife.load_knife_config(File.join(APP_ROOT, 'spec/knife.rb'))
 end
 
 Spork.each_run do

data/spec/support/chef_api.rb

@@ -24,8 +24,7 @@ module Berkshelf
         else
           ridley.cookbook.delete(name, version)
         end
-      rescue Ridley::Errors::HTTPNotFound,
-             Ridley::Errors::ResourceNotFound
+      rescue Ridley::Errors::HTTPNotFound
         true
       end
 
@@ -37,8 +36,7 @@ module Berkshelf
         else
           !versions.find { |ver| ver == version }.nil?
         end
-      rescue Ridley::Errors::HTTPNotFound,
-             Ridley::Errors::ResourceNotFound
+      rescue Ridley::Errors::HTTPNotFound
         false
       end
 
@@ -89,10 +87,26 @@ EOF
         File.open(cookbook_path.join("metadata.rb"), 'w+') do |f|
           f.write metadata
         end
-        
+
         cookbook_path
       end
 
+      def create_environment(environment_name)
+        ridley.environment.create(name: environment_name)
+      end
+
+      def delete_environment(environment_name)
+        ridley.environment.delete(environment_name)
+      end
+
+      def environment(environment_name)
+        ridley.environment.find(environment_name)
+      end
+
+      def environment_exists?(environment_name)
+        !environment(environment_name).nil?
+      end
+
       private
 
         def ridley

data/spec/support/chef_server.rb

@@ -14,14 +14,15 @@ module Berkshelf::RSpec
       end
 
       def server
-        @server ||= ChefZero::Server.new(port: PORT, generate_real_keys: false)
+        @server ||= ChefZero::Server.new(port: PORT, signals: false, log_requests: true)
       end
 
       def server_url
-        (@server && @server.url) || "http://localhost:#{PORT}"
+        "http://localhost:#{PORT}"
       end
 
       def start
+        Thin::Logging.silent = true
         server.start_background
         server.on_response do |request, response|
           request_log << [ request, response ]
@@ -32,7 +33,7 @@ module Berkshelf::RSpec
       end
 
       def stop
-        @server.stop if running?
+        @server.stop if @server
       end
 
       def running?

data/spec/support/knife.rb

@@ -0,0 +1,18 @@
+require 'berkshelf/chef'
+
+module Berkshelf
+  module RSpec
+    module Knife
+      class << self
+        def load_knife_config(path)
+          if File.exist?(path)
+            Berkshelf::Chef::Config.from_file(path)
+            ENV["CHEF_CONFIG"] = path
+          else
+            raise "Cannot continue; '#{path}' must exist and have testing credentials." unless ENV['CI']
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/berkshelf/berksfile_spec.rb

@@ -1,174 +1,162 @@
 require 'spec_helper'
 
 describe Berkshelf::Berksfile do
-  let(:content) do
-<<-EOF
-cookbook 'ntp', '<= 1.0.0'
-cookbook 'mysql'
-cookbook 'nginx', '< 0.101.2'
-cookbook 'ssh_known_hosts2', :git => 'https://github.com/erikh/chef-ssh_known_hosts2.git'
-EOF
-  end
+  describe '.from_file' do
+    let(:cookbook_file) { fixtures_path.join('lockfile_spec', 'with_lock', 'Berksfile') }
 
-  describe "ClassMethods" do
-    subject { described_class }
+    it 'reads a Berksfile and returns an instance Berksfile' do
+      expect(Berkshelf::Berksfile.from_file(cookbook_file)).to be_a(Berkshelf::Berksfile)
+    end
 
-    describe "::from_file" do
-      let(:cookbook_file) { fixtures_path.join('lockfile_spec', 'with_lock', 'Berksfile') }
+    context 'when Berksfile does not exist at given path' do
+      let(:bad_path) { tmp_path.join('thisdoesnotexist') }
 
-      it "reads a Berksfile and returns an instance Berksfile" do
-        subject.from_file(cookbook_file).should be_a(Berkshelf::Berksfile)
+      it 'raises BerksfileNotFound' do
+        expect {
+          Berkshelf::Berksfile.from_file(bad_path)
+        }.to raise_error(Berkshelf::BerksfileNotFound)
       end
+    end
+  end
 
-      context "when Berksfile does not exist at given path" do
-        let(:bad_path) { tmp_path.join("thisdoesnotexist") }
+  describe '.vendor' do
+    let(:cached_cookbooks) { [] }
+    let(:tmpdir) { Dir.mktmpdir(nil, tmp_path) }
 
-        it "raises BerksfileNotFound" do
-          lambda {
-            subject.from_file(bad_path)
-          }.should raise_error(Berkshelf::BerksfileNotFound)
-        end
-      end
+    it 'returns the expanded filepath of the vendor directory' do
+      expect(Berkshelf::Berksfile.vendor(cached_cookbooks, tmpdir)).to eql(tmpdir)
     end
 
-    describe "::vendor" do
-      let(:cached_cookbooks) { [] }
-      let(:tmpdir) { Dir.mktmpdir(nil, tmp_path) }
-
-      it "returns the expanded filepath of the vendor directory" do
-        subject.vendor(cached_cookbooks, tmpdir).should eql(tmpdir)
+    context 'with a chefignore' do
+      before do
+        File.stub(:exists?).and_return(true)
+        Berkshelf::Chef::Cookbook::Chefignore.any_instance.stub(:remove_ignores_from).and_return(['metadata.rb'])
       end
 
-      context "with a chefignore" do
-        it "finds a chefignore file" do
-          Berkshelf::Chef::Cookbook::Chefignore.should_receive(:find_relative_to).and_return(File.expand_path('chefignore'))
-          subject.vendor(cached_cookbooks, tmpdir)
-        end
+      it 'finds a chefignore file' do
+        Berkshelf::Chef::Cookbook::Chefignore.should_receive(:new).with(File.expand_path('chefignore'))
+        Berkshelf::Berksfile.vendor(cached_cookbooks, tmpdir)
+      end
 
-        it "ignores files specified by a chefignore if a chefignore is present" do
-          Berkshelf::Chef::Cookbook::Chefignore.should_receive(:find_relative_to).and_return(File.expand_path('chefignore'))
-          Berkshelf::Chef::Cookbook::Chefignore.any_instance.stub(:remove_ignores_from).and_return(['metadata.rb'])
-          subject.vendor(cached_cookbooks, tmpdir)
-        end
+      it 'removes files in chefignore' do
+        cached_cookbooks = [ Berkshelf::CachedCookbook.from_path(fixtures_path.join('cookbooks/example_cookbook')) ]
+        FileUtils.should_receive(:cp_r).with(['metadata.rb'], anything()).exactly(1).times
+        FileUtils.should_receive(:cp_r).with(anything(), anything(), anything()).once
+        Berkshelf::Berksfile.vendor(cached_cookbooks, tmpdir)
       end
     end
   end
 
-  let(:source_one) { double('source_one', name: "nginx") }
-  let(:source_two) { double('source_two', name: "mysql") }
 
-  subject { described_class.new(tmp_path.join("Berksfile")) }
 
-  describe "#cookbook" do
-    let(:name) { "artifact" }
+  let(:source_one) { double('source_one', name: 'nginx') }
+  let(:source_two) { double('source_two', name: 'mysql') }
+
+  subject do
+    berksfile_path = tmp_path.join('Berksfile').to_s
+    FileUtils.touch(berksfile_path)
+    Berkshelf::Berksfile.new(berksfile_path)
+  end
+
+  describe '#cookbook' do
+    let(:name) { 'artifact' }
     let(:constraint) { double('constraint') }
     let(:default_options) { { group: [] } }
 
-    it "sends the add_source message with the name, constraint, and options to the instance of the includer" do
+    it 'sends the add_source message with the name, constraint, and options to the instance of the includer' do
       subject.should_receive(:add_source).with(name, constraint, default_options)
-
-      subject.cookbook name, constraint, default_options
+      subject.cookbook(name, constraint, default_options)
     end
 
-    it "merges the default options into specified options" do
-      subject.should_receive(:add_source).with(name, constraint, path: "/Users/reset", group: [])
-
-      subject.cookbook name, constraint, path: "/Users/reset"
+    it 'merges the default options into specified options' do
+      subject.should_receive(:add_source).with(name, constraint, path: '/Users/reset', group: [])
+      subject.cookbook(name, constraint, path: '/Users/reset')
     end
 
-    it "converts a single specified group option into an array of groups" do
+    it 'converts a single specified group option into an array of groups' do
       subject.should_receive(:add_source).with(name, constraint, group: [:production])
-
-      subject.cookbook name, constraint, group: :production
+      subject.cookbook(name, constraint, group: :production)
     end
 
-    context "when no constraint specified" do
-      it "sends the add_source message with a nil value for constraint" do
+    context 'when no constraint specified' do
+      it 'sends the add_source message with a nil value for constraint' do
         subject.should_receive(:add_source).with(name, nil, default_options)
-
-        subject.cookbook name, default_options
+        subject.cookbook(name, default_options)
       end
     end
 
-    context "when no options specified" do
-      it "sends the add_source message with an empty Hash for the value of options" do
+    context 'when no options specified' do
+      it 'sends the add_source message with an empty Hash for the value of options' do
         subject.should_receive(:add_source).with(name, constraint, default_options)
-
-        subject.cookbook name, constraint
+        subject.cookbook(name, constraint)
       end
     end
   end
 
   describe '#group' do
-    let(:name) { "artifact" }
-    let(:group) { "production" }
+    let(:name) { 'artifact' }
+    let(:group) { 'production' }
 
-    it "sends the add_source message with an array of groups determined by the parameter passed to the group block" do
+    it 'sends the add_source message with an array of groups determined by the parameter passed to the group block' do
       subject.should_receive(:add_source).with(name, nil, group: [group])
 
-      subject.group group do
-        subject.cookbook name
+      subject.group(group) do
+        subject.cookbook(name)
       end
     end
   end
 
-  describe "#metadata" do
-    let(:cb_path) { fixtures_path.join('cookbooks/example_cookbook') }
-    subject { described_class.new(cb_path.join("Berksfile")) }
+  describe '#metadata' do
+    let(:path) { fixtures_path.join('cookbooks/example_cookbook') }
+    subject { Berkshelf::Berksfile.new(path.join('Berksfile')) }
 
-    before(:each) { Dir.chdir(cb_path) }
-
-    it "sends the add_source message with an explicit version constraint and the path to the cookbook" do
-      subject.should_receive(:add_source).with("example_cookbook", "= 0.5.0", path: cb_path.to_s)
+    before { Dir.chdir(path) }
 
+    it 'sends the add_source message with an explicit version constraint and the path to the cookbook' do
+      subject.should_receive(:add_source).with('example_cookbook', '= 0.5.0', path: path.to_s)
       subject.metadata
     end
   end
 
-  describe "#site" do
-    let(:uri) { "http://opscode/v1" }
+  describe '#site' do
+    let(:uri) { 'http://opscode/v1' }
 
-    it "sends the add_location to the instance of the implementing class with a SiteLocation" do
+    it 'sends the add_location to the instance of the implementing class with a SiteLocation' do
       subject.should_receive(:add_location).with(:site, uri)
-
       subject.site(uri)
     end
 
-    context "given the symbol :opscode" do
-      it "sends an add_location message with the default Opscode Community API as the first parameter" do
+    context 'given the symbol :opscode' do
+      it 'sends an add_location message with the default Opscode Community API as the first parameter' do
         subject.should_receive(:add_location).with(:site, :opscode)
-
         subject.site(:opscode)
       end
     end
   end
 
-  describe "#chef_api" do
-    let(:uri) { "http://chef:8080/" }
+  describe '#chef_api' do
+    let(:uri) { 'http://chef:8080/' }
 
-    it "sends and add_location message with the type :chef_api and the given URI" do
+    it 'sends and add_location message with the type :chef_api and the given URI' do
       subject.should_receive(:add_location).with(:chef_api, uri, {})
-
       subject.chef_api(uri)
     end
 
-    it "also sends any options passed" do
-      options = { node_name: "reset", client_key: "/Users/reset/.chef/reset.pem" }
+    it 'also sends any options passed' do
+      options = { node_name: 'reset', client_key: '/Users/reset/.chef/reset.pem' }
       subject.should_receive(:add_location).with(:chef_api, uri, options)
-
       subject.chef_api(uri, options)
     end
 
-    context "given the symbol :config" do
-      it "sends an add_location message with the the type :chef_api and the URI :config" do
+    context 'given the symbol :config' do
+      it 'sends an add_location message with the the type :chef_api and the URI :config' do
         subject.should_receive(:add_location).with(:chef_api, :config, {})
-
         subject.chef_api(:config)
       end
     end
   end
 
-  describe "#sources" do
+  describe '#sources' do
     let(:groups) do
       [
         :nautilus,
@@ -176,146 +164,146 @@ EOF
       ]
     end
 
-    it "returns all CookbookSources added to the instance of Berksfile" do
+    it 'returns all CookbookSources added to the instance of Berksfile' do
       subject.add_source(source_one.name)
       subject.add_source(source_two.name)
 
-      subject.sources.should have(2).items
-      subject.should have_source(source_one.name)
-      subject.should have_source(source_two.name)
+      expect(subject.sources).to have(2).items
+      expect(subject).to have_source(source_one.name)
+      expect(subject).to have_source(source_two.name)
     end
 
-    context "given the option :except" do
-      before(:each) do
+    context 'given the option :except' do
+      before do
         source_one.stub(:groups) { [:default, :skarner] }
         source_two.stub(:groups) { [:default, :nautilus] }
       end
 
-      it "returns all of the sources except the ones in the given groups" do
+      it 'returns all of the sources except the ones in the given groups' do
         subject.add_source(source_one.name, nil, group: [:default, :skarner])
         subject.add_source(source_two.name, nil, group: [:default, :nautilus])
         filtered = subject.sources(except: :nautilus)
 
-        filtered.should have(1).item
-        filtered.first.name.should eql(source_one.name)
+        expect(filtered).to have(1).item
+        expect(filtered.first.name).to eq(source_one.name)
       end
     end
 
-    context "given the option :only" do
-      before(:each) do
+    context 'given the option :only' do
+      before do
         source_one.stub(:groups) { [:default, :skarner] }
         source_two.stub(:groups) { [:default, :nautilus] }
       end
 
-      it "returns only the sources in the givne groups" do
+      it 'returns only the sources in the givne groups' do
         subject.add_source(source_one.name, nil, group: [:default, :skarner])
         subject.add_source(source_two.name, nil, group: [:default, :nautilus])
         filtered = subject.sources(only: :nautilus)
 
-        filtered.should have(1).item
-        filtered.first.name.should eql(source_two.name)
+        expect(filtered).to have(1).item
+        expect(filtered.first.name).to eq(source_two.name)
       end
     end
 
-    context "when a value for :only and :except is given" do
-      it "raises an ArgumentError" do
-        lambda {
+    context 'when a value for :only and :except is given' do
+      it 'raises an ArgumentError' do
+        expect {
           subject.sources(only: [:default], except: [:other])
-        }.should raise_error(Berkshelf::ArgumentError, "Cannot specify both :except and :only")
+        }.to raise_error(Berkshelf::ArgumentError, "Cannot specify both :except and :only")
       end
     end
   end
 
-  describe "#groups" do
-    before(:each) do
+  describe '#groups' do
+    before do
       subject.stub(:sources) { [source_one, source_two] }
       source_one.stub(:groups) { [:nautilus, :skarner] }
       source_two.stub(:groups) { [:nautilus, :riven] }
     end
 
-    it "returns a hash containing keys for every group a source is a member of" do
-      subject.groups.keys.should have(3).items
-      subject.groups.should have_key(:nautilus)
-      subject.groups.should have_key(:skarner)
-      subject.groups.should have_key(:riven)
+    it 'returns a hash containing keys for every group a source is a member of' do
+      expect(subject.groups.keys).to have(3).items
+      expect(subject.groups).to have_key(:nautilus)
+      expect(subject.groups).to have_key(:skarner)
+      expect(subject.groups).to have_key(:riven)
     end
 
-    it "returns an Array of CookbookSources who are members of the group for value" do
-      subject.groups[:nautilus].should have(2).items
-      subject.groups[:riven].should have(1).item
+    it 'returns an Array of CookbookSources who are members of the group for value' do
+      expect(subject.groups[:nautilus]).to have(2).items
+      expect(subject.groups[:riven]).to have(1).item
     end
   end
 
-  describe "#resolve" do
+  describe '#resolve' do
     let(:resolver) { double('resolver') }
-    before(:each) { Berkshelf::Resolver.stub(:new) { resolver } }
+    let(:sources) { [source_one, source_two] }
+    let(:cached) { [double('cached_one'), double('cached_two')] }
+
+    before do
+      Berkshelf::Resolver.stub(:new).and_return(resolver)
+    end
+
+    it 'resolves the Berksfile' do
+      resolver.should_receive(:resolve).and_return(cached)
+      resolver.should_receive(:sources).and_return(sources)
 
-    it "resolves the Berksfile" do
-      resolver.should_receive(:resolve).and_return([double('cached_cookbook_one'), double('cached_cookbook_two')])
-      solution = subject.resolve
-      solution.should have(2).items
+      expect(subject.resolve).to eq({ solution: cached, sources: sources })
     end
   end
 
-  describe "#install" do
+  describe '#install' do
     let(:resolver) { double('resolver') }
-    before(:each) { Berkshelf::Resolver.stub(:new) { resolver } }
+    let(:lockfile) { double('lockfile') }
 
-    context "when a lockfile is not present" do
-      before(:each) do
-        subject.should_receive(:lockfile_present?).and_return(false)
-        resolver.should_receive(:sources).and_return([])
-      end
+    let(:cached_cookbooks) { [double('cached_one'), double('cached_two')] }
+    let(:sources) { [source_one, source_two] }
 
-      let(:cached_cookbooks) do
-        [
-          double('cached_one'),
-          double('cached_two')
-        ]
-      end
+    before do
+      Berkshelf::Resolver.stub(:new).and_return(resolver)
+      Berkshelf::Lockfile.stub(:new).and_return(lockfile)
 
-      it "returns the result from sending the message resolve to resolver" do
-        resolver.should_receive(:resolve).and_return(cached_cookbooks)
+      subject.stub(:sha).and_return('abc123')
 
-        subject.install.should eql(cached_cookbooks)
+      lockfile.stub(:sources).and_return([])
+      lockfile.stub(:sha).and_return('xyz456')
+
+      resolver.stub(:sources).and_return([])
+      lockfile.stub(:update)
+    end
+
+    context 'when a lockfile is not present' do
+      it 'returns the result from sending the message resolve to resolver' do
+        resolver.should_receive(:resolve).and_return(cached_cookbooks)
+        expect(subject.install).to eql(cached_cookbooks)
       end
 
-      it "sets a value for self.cached_cookbooks equivalent to the return value" do
+      it 'sets a value for self.cached_cookbooks equivalent to the return value' do
         resolver.should_receive(:resolve).and_return(cached_cookbooks)
         subject.install
 
-        subject.cached_cookbooks.should eql(cached_cookbooks)
+        expect(subject.cached_cookbooks).to eql(cached_cookbooks)
       end
 
-      it "creates a new resolver and finds a solution by calling resolve on the resolver" do
+      it 'creates a new resolver and finds a solution by calling resolve on the resolver' do
         resolver.should_receive(:resolve)
-
         subject.install
       end
 
-      it "writes a lockfile with the resolvers sources" do
+      it 'writes a lockfile with the resolvers sources' do
         resolver.should_receive(:resolve)
-        subject.should_receive(:write_lockfile).with([])
+        lockfile.should_receive(:update).with([], sha: 'abc123')
 
         subject.install
       end
     end
 
-    context "when a lockfile is present" do
-      before(:each) { subject.should_receive(:lockfile_present?).and_return(true) }
-
-      it "does not write a new lock file" do
+    context 'when a value for :path is given' do
+      before do
         resolver.should_receive(:resolve)
-        subject.should_not_receive(:write_lockfile)
-
-        subject.install
+        resolver.should_receive(:sources).and_return([])
       end
-    end
-
-    context "when a value for :path is given" do
-      before(:each) { resolver.should_receive(:resolve) }
 
-      it "sends the message 'vendor' to Berksfile with the value for :path" do
+      it 'sends the message :vendor to Berksfile with the value for :path' do
         path = double('path')
         subject.class.should_receive(:vendor).with(subject.cached_cookbooks, path)
 
@@ -323,99 +311,113 @@ EOF
       end
     end
 
-    context "when a value for :except is given" do
-      before(:each) { resolver.should_receive(:resolve) }
-
-      it "filters the sources and gives the results to the Resolver initializer" do
-        filtered = double('sources')
-        subject.should_receive(:sources).with(except: [:skip_me]).and_return(filtered)
-        Berkshelf::Resolver.should_receive(:new).with(anything, sources: filtered)
+    context 'when a value for :except is given' do
+      before do
+        resolver.should_receive(:resolve)
+        resolver.should_receive(:sources).and_return([])
+        subject.stub(:sources).and_return(sources)
+        subject.stub(:apply_lockfile).and_return(sources)
+      end
 
+      it 'filters the sources and gives the results to the Resolver initializer' do
+        subject.should_receive(:sources).with(except: [:skip_me]).and_return(sources)
         subject.install(except: [:skip_me])
       end
     end
 
-    context "when a value for :only is given" do
-      before(:each) { resolver.should_receive(:resolve) }
-
-      it "filters the sources and gives the results to the Resolver initializer" do
-        filtered = double('sources')
-        subject.should_receive(:sources).with(only: [:skip_me]).and_return(filtered)
+    context 'when a value for :only is given' do
+      before do
+        resolver.should_receive(:resolve)
+        resolver.should_receive(:sources).and_return([])
+        subject.stub(:sources).and_return(sources)
+        subject.stub(:apply_lockfile).and_return(sources)
+      end
 
+      it 'filters the sources and gives the results to the Resolver initializer' do
+        subject.should_receive(:sources).with(only: [:skip_me]).and_return(sources)
         subject.install(only: [:skip_me])
       end
     end
   end
 
-  describe "#load" do
-    it "reads the content of a Berksfile and adds the sources to the Shelf" do
+  describe '#load' do
+    let(:content) do
+      <<-EOF.strip
+      cookbook 'ntp', '<= 1.0.0'
+      cookbook 'mysql'
+      cookbook 'nginx', '< 0.101.2'
+      cookbook 'ssh_known_hosts2', :git => 'https://github.com/erikh/chef-ssh_known_hosts2.git'
+      EOF
+    end
+
+    it 'reads the content of a Berksfile and adds the sources to the Shelf' do
       subject.load(content)
 
-      ['ntp', 'mysql', 'nginx', 'ssh_known_hosts2'].each do |name|
-        subject.should have_source(name)
+      %w(ntp mysql nginx ssh_known_hosts2).each do |name|
+        expect(subject).to have_source(name)
       end
     end
 
-    it "returns an instance of Berksfile" do
-      subject.load(content).should be_a(described_class)
+    it 'returns an instance of Berksfile' do
+      expect(subject.load(content)).to be_a(Berkshelf::Berksfile)
     end
   end
 
-  describe "#add_source" do
-    let(:name) { "cookbook_one" }
-    let(:constraint) { "= 1.2.0" }
-    let(:location) { { site: "http://site" } }
+  describe '#add_source' do
+    let(:name) { 'cookbook_one' }
+    let(:constraint) { '= 1.2.0' }
+    let(:location) { { site: 'http://site' } }
 
     before(:each) do
       subject.add_source(name, constraint, location)
     end
 
-    it "adds new cookbook source to the list of sources" do
-      subject.sources.should have(1).source
+    it 'adds new cookbook source to the list of sources' do
+      expect(subject.sources).to have(1).source
     end
 
     it "adds a cookbook source with a 'name' of the given name" do
-      subject.sources.first.name.should eql(name)
+      expect(subject.sources.first.name).to eq(name)
     end
 
     it "adds a cookbook source with a 'version_constraint' of the given constraint" do
-      subject.sources.first.version_constraint.to_s.should eql(constraint)
+      expect(subject.sources.first.version_constraint.to_s).to eq(constraint)
     end
 
-    it "raises DuplicateSourceDefined if multiple sources of the same name are found" do
-      lambda {
+    it 'raises DuplicateSourceDefined if multiple sources of the same name are found' do
+      expect {
         subject.add_source(name)
-      }.should raise_error(Berkshelf::DuplicateSourceDefined)
+      }.to raise_error(Berkshelf::DuplicateSourceDefined)
     end
   end
 
-  describe "#add_location" do
+  describe '#add_location' do
     let(:type) { :site }
     let(:value) { double('value') }
     let(:options) { double('options') }
 
-    it "delegates 'add_location' to the downloader" do
+    it 'delegates :add_location to the downloader' do
       subject.downloader.should_receive(:add_location).with(type, value, options)
-
       subject.add_location(type, value, options)
     end
   end
 
-  describe "#upload" do
+  describe '#upload' do
     let(:upload) { subject.upload(options) }
     let(:options) { Hash.new }
     let(:ssl) { double('ssl', verify: true) }
     let(:chef) {
       double('chef',
-        node_name: "fake-client",
-        client_key: "client-key",
-        chef_server_url: "http://configured-chef-server/")
+        node_name: 'fake-client',
+        client_key: 'client-key',
+        chef_server_url: 'http://configured-chef-server/'
+      )
     }
     let(:berkshelf_config) { double('berks', ssl: ssl, chef: chef) }
     let(:default_ridley_options) {
       {
-        client_name: "fake-client",
-        client_key: "client-key",
+        client_name: 'fake-client',
+        client_key: 'client-key',
         ssl: {
           verify: true
         }
@@ -424,82 +426,177 @@ EOF
 
     before do
       Berkshelf::Config.stub(:instance).and_return(berkshelf_config)
-      subject.stub(:resolve).and_return([])
+      subject.stub(:resolve).and_return(solution: [], sources: [])
     end
 
-    context "when there is no :server_url" do
-      let(:chef) {
+    context 'when there is no :server_url' do
+      let(:chef) do
         double('chef',
-          node_name: "fake-client",
-          client_key: "client-key",
-          chef_server_url: nil)
-      }
-      let(:message) { "Missing required attribute in your Berkshelf configuration: chef.server_url" }
+          node_name: 'fake-client',
+          client_key: 'client-key',
+          chef_server_url: nil
+        )
+      end
+      let(:message) { 'Missing required attribute in your Berkshelf configuration: chef.server_url' }
 
-      it "raises an error" do
+      it 'raises an error' do
         expect {
           upload
-        }.to raise_error(Berkshelf::UploadFailure, message)
+        }.to raise_error(Berkshelf::ChefConnectionError, message)
       end
     end
 
-    context "when there is no :client_name" do
-      let(:chef) {
+    context 'when there is no :client_name' do
+      let(:chef) do
         double('chef',
           node_name: nil,
-          client_key: "client-key",
-          chef_server_url: "http://configured-chef-server/")
-      }
-      let(:message) { "Missing required attribute in your Berkshelf configuration: chef.node_name" }
+          client_key: 'client-key',
+          chef_server_url: 'http://configured-chef-server/'
+        )
+      end
+      let(:message) { 'Missing required attribute in your Berkshelf configuration: chef.node_name' }
 
-      it "raises an error" do
+      it 'raises an error' do
         expect {
           upload
-        }.to raise_error(Berkshelf::UploadFailure, message)
+        }.to raise_error(Berkshelf::ChefConnectionError, message)
       end
     end
 
-    context "when there is no :client_key" do
-      let(:chef) {
+    context 'when there is no :client_key' do
+      let(:chef) do
         double('chef',
-          node_name: "fake-client",
+          node_name: 'fake-client',
           client_key: nil,
-          chef_server_url: "http://configured-chef-server/")
-      }
-      let(:message) { "Missing required attribute in your Berkshelf configuration: chef.client_key" }
+          chef_server_url: 'http://configured-chef-server/'
+        )
+      end
+      let(:message) { 'Missing required attribute in your Berkshelf configuration: chef.client_key' }
 
-      it "raises an error" do
+      it 'raises an error' do
         expect {
           upload
-        }.to raise_error(Berkshelf::UploadFailure, message)
+        }.to raise_error(Berkshelf::ChefConnectionError, message)
       end
     end
 
-    context "when a Chef Server url is not passed as an option" do
+    context 'when a Chef Server url is not passed as an option' do
       let(:ridley_options) do
-        {server_url: "http://configured-chef-server/"}.merge(default_ridley_options)
+        { server_url: 'http://configured-chef-server/' }.merge(default_ridley_options)
       end
 
-      it "uses Berkshelf::Config configured server_url" do
+      it 'uses Berkshelf::Config configured server_url' do
         Ridley.should_receive(:new).with(ridley_options)
         upload
       end
     end
 
-    context "when a Chef Server url is passed as an option" do
-      let(:options) {
+    context 'when a Chef Server url is passed as an option' do
+      let(:options) do
         {
-          server_url: "http://fake-chef-server.com/"
+          server_url: 'http://fake-chef-server.com/'
         }
-      }
-      let(:ridley_options) {
-        {server_url: "http://fake-chef-server.com/"}.merge(default_ridley_options)
-      }
+      end
+      let(:ridley_options) do
+        { server_url: 'http://fake-chef-server.com/'}.merge(default_ridley_options)
+      end
 
-      it "uses the passed in :server_url" do
+      it 'uses the passed in :server_url' do
         Ridley.should_receive(:new).with(ridley_options)
         upload
       end
     end
   end
+
+  describe '#apply' do
+    let(:env_name)    { 'berkshelf-test' }
+    let(:server_url)  { Berkshelf::RSpec::ChefServer.server_url }
+    let(:client_name) { 'reset' }
+    let(:client_key)  { fixtures_path.join('reset.pem').to_s }
+    let(:ridley)      { Ridley.new(server_url: server_url, client_name: client_name, client_key: client_key) }
+
+    before do
+      subject.stub(:ridley_connection).and_return(ridley)
+      subject.add_source('nginx', '>= 0.1.2', chef_api: server_url, node_name: client_name, client_key: client_key)
+      subject.stub(install: nil)
+    end
+
+    context 'when the chef environment exists' do
+      let(:sources) do
+        [
+          double(name: 'nginx', locked_version: '1.2.3'),
+          double(name: 'artifact', locked_version: '1.4.0')
+        ]
+      end
+
+      before do
+        chef_environment('berkshelf')
+        subject.lockfile.stub(:sources).and_return(sources)
+      end
+
+      it 'installs the Berksfile' do
+        subject.should_receive(:install)
+        subject.apply('berkshelf')
+      end
+
+      it 'applys the locked_versions of the Lockfile sources to the given Chef environment' do
+        subject.apply('berkshelf')
+
+        environment = ::JSON.parse(chef_server.data['environments']['berkshelf'])
+        expect(environment['cookbook_versions']).to have(2).items
+        expect(environment['cookbook_versions']['nginx']).to eq('1.2.3')
+        expect(environment['cookbook_versions']['artifact']).to eq('1.4.0')
+      end
+    end
+
+    context 'when the environment does not exist' do
+      it 'raises an EnvironmentNotFound error' do
+        expect {
+          subject.apply(env_name)
+        }.to raise_error(Berkshelf::EnvironmentNotFound)
+      end
+    end
+
+    context 'when Ridley throw an exception' do
+      before { ridley.stub_chain(:environment, :find).and_raise(Ridley::Errors::RidleyError) }
+
+      it 'raises a ChefConnectionError' do
+        expect {
+          subject.apply(env_name)
+        }.to raise_error(Berkshelf::ChefConnectionError)
+      end
+    end
+  end
+
+  describe '#package' do
+    context 'when the source does not exist' do
+      it 'raises a CookbookNotFound exception' do
+        expect {
+          subject.package('non-existent', output: '/tmp')
+        }.to raise_error(Berkshelf::CookbookNotFound)
+      end
+    end
+
+    context 'when the source exists' do
+      let(:source) { double('source') }
+      let(:cached) { double('cached', path: '/foo/bar', cookbook_name: 'cookbook') }
+      let(:options) { { output: '/tmp' } }
+
+      before do
+        FileUtils.stub(:cp_r)
+        FileUtils.stub(:mkdir_p)
+        subject.stub(:find).with('non-existent').and_return(source)
+        subject.stub(:resolve).with(source, options).and_return({ solution: [cached], sources: [source] })
+      end
+
+      it 'resolves the sources' do
+        subject.should_receive(:resolve).with(source, options)
+        subject.package('non-existent', options)
+      end
+
+      it 'returns the output path' do
+        expect(subject.package('non-existent', options)).to eq('/tmp/non-existent.tar.gz')
+      end
+    end
+  end
 end