berkshelf 3.0.0.beta6 → 3.0.0.beta7

data/lib/berkshelf/resolver.rb

@@ -71,8 +71,10 @@ module Berkshelf
       graph.populate(berksfile.sources)
 
       Solve.it!(graph, demand_array, ENV['DEBUG_RESOLVER'] ? { ui: Berkshelf.ui } : {}).collect do |name, version|
-        dependency = get_demand(name) || Dependency.new(berksfile, name, locked_version: version)
-        [ name, version, dependency ]
+        dependency = get_demand(name) || Dependency.new(berksfile, name)
+        dependency.locked_version = version
+
+        dependency
       end
     rescue Solve::Errors::NoSolutionError
       raise Berkshelf::NoSolutionError.new(demands)

data/lib/berkshelf/source.rb

@@ -44,6 +44,15 @@ module Berkshelf
       universe.find { |cookbook| cookbook.name == name && cookbook.version == version }
     end
 
+    # Determine if this source is a "default" source, as defined in the
+    # {Berksfile}.
+    #
+    # @return [true, false]
+    #   true if this a default source, false otherwise
+    def default?
+      uri == Berksfile::DEFAULT_API_URL
+    end
+
     # @param [String] name
     #
     # @return [APIClient::RemoteCookbook]
@@ -59,7 +68,7 @@ module Berkshelf
     end
 
     def to_s
-      uri.to_s
+      "#{uri}"
     end
 
     def ==(other)

data/lib/berkshelf/version.rb

@@ -1,3 +1,3 @@
 module Berkshelf
-  VERSION = "3.0.0.beta6"
+  VERSION = "3.0.0.beta7"
 end

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

@@ -1,4 +1,3 @@
-{
-  "dependencies": {
-  }
-}
+DEPENDENCIES
+
+GRAPH

data/spec/fixtures/lockfiles/2.0.lock

@@ -0,0 +1,17 @@
+{
+  "dependencies": {
+    "jenkins": {
+      "locked_version": "2.0.3",
+      "path": "."
+    },
+    "apt": {
+      "locked_version": "2.3.6"
+    },
+    "runit": {
+      "locked_version": "1.5.8"
+    },
+    "yum": {
+      "locked_version": "3.0.6"
+    }
+  }
+}

data/spec/fixtures/lockfiles/default.lock

@@ -1,10 +1,18 @@
-{
-  "dependencies":{
-    "build-essential":{
-      "locked_version":"1.1.2"
-    },
-    "chef-client":{
-      "locked_version":"2.1.4"
-    }
-  }
-}
+DEPENDENCIES
+  apt (~> 2.0)
+  jenkins (~> 2.0)
+
+GRAPH
+  apt (2.3.6)
+  build-essential (1.4.2)
+  jenkins (2.0.3)
+    apt (~> 2.0)
+    runit (~> 1.5)
+    yum (~> 3.0)
+  runit (1.5.8)
+    build-essential (>= 0.0.0)
+    yum (~> 3.0)
+    yum-epel (>= 0.0.0)
+  yum (3.0.6)
+  yum-epel (0.2.0)
+    yum (~> 3.0)

data/spec/fixtures/lockfiles/empty.lock

@@ -0,0 +1,3 @@
+DEPENDENCIES
+
+GRAPH

data/spec/unit/berkshelf/berksfile_spec.rb

@@ -2,16 +2,6 @@ require 'spec_helper'
 
 describe Berkshelf::Berksfile do
   describe "ClassMethods" do
-    describe "::default_sources" do
-      subject { described_class.default_sources }
-
-      it "returns an array including the default sources" do
-        expect(subject).to be_a(Array)
-        expect(subject).to have(1).item
-        expect(subject.map(&:to_s)).to include("https://api.berkshelf.com")
-      end
-    end
-
     describe '::from_file' do
       let(:content) do
         <<-EOF.strip
@@ -152,14 +142,6 @@ describe Berkshelf::Berksfile do
       expect(subject.sources[1].to_s).to_not eq(new_source)
     end
 
-    context "when a source is explicitly specified" do
-      it "does not include the default sources in the list" do
-        subject.source(new_source)
-        expect(subject.sources).to have(1).item
-        expect(subject.sources).to_not include(described_class.default_sources)
-      end
-    end
-
     context "adding an invalid source" do
       let(:invalid_uri) { ".....$1233...." }
 
@@ -170,18 +152,26 @@ describe Berkshelf::Berksfile do
   end
 
   describe "#sources" do
-    it "returns an Array" do
-      expect(subject.sources).to be_a(Array)
+    context "when there are no sources" do
+      it "raises an exception" do
+        expect {
+          subject.sources
+        }.to raise_error(Berkshelf::NoAPISourcesDefined)
+      end
     end
 
-    it "contains a collection of Berkshelf::Source" do
-      subject.sources.each do |source|
-        expect(source).to be_a(Berkshelf::Source)
+    context "when there are sources" do
+      before { subject.source("https://api.berkshelf.org") }
+
+      it "returns an Array" do
+        expect(subject.sources).to be_a(Array)
       end
-    end
 
-    it "includes the default sources" do
-      expect(subject.sources).to include(*described_class.default_sources)
+      it "contains a collection of Berkshelf::Source" do
+        subject.sources.each do |source|
+          expect(source).to be_a(Berkshelf::Source)
+        end
+      end
     end
   end
 
@@ -213,45 +203,21 @@ describe Berkshelf::Berksfile do
       expect(subject).to have_dependency(dependency_one.name)
       expect(subject).to have_dependency(dependency_two.name)
     end
+  end
 
-    context 'given the option :except' do
-      before do
-        dependency_one.stub(:groups) { [:default, :skarner] }
-        dependency_two.stub(:groups) { [:default, :nautilus] }
-      end
-
-      it 'returns all of the dependencies except the ones in the given groups' do
-        subject.add_dependency(dependency_one.name, nil, group: [:default, :skarner])
-        subject.add_dependency(dependency_two.name, nil, group: [:default, :nautilus])
-        filtered = subject.dependencies(except: :nautilus)
-
-        expect(filtered).to have(1).item
-        expect(filtered.first.name).to eq(dependency_one.name)
-      end
+  describe '#cookbooks' do
+    it 'raises an exception if a cookbook is not installed' do
+      subject.add_dependency('bacon', nil)
+      expect { subject.cookbooks }.to raise_error
     end
 
-    context 'given the option :only' do
-      before do
-        dependency_one.stub(:groups) { [:default, :skarner] }
-        dependency_two.stub(:groups) { [:default, :nautilus] }
-      end
-
-      it 'returns only the dependencies in the givne groups' do
-        subject.add_dependency(dependency_one.name, nil, group: [:default, :skarner])
-        subject.add_dependency(dependency_two.name, nil, group: [:default, :nautilus])
-        filtered = subject.dependencies(only: :nautilus)
+    it 'retrieves the locked (cached) cookbook for each dependency' do
+      subject.add_dependency('bacon', nil)
+      subject.add_dependency('ham', nil)
+      subject.stub(:retrive_locked)
 
-        expect(filtered).to have(1).item
-        expect(filtered.first.name).to eq(dependency_two.name)
-      end
-    end
-
-    context 'when a value for :only and :except is given' do
-      it 'raises an ArgumentError' do
-        expect {
-          subject.dependencies(only: [:default], except: [:other])
-        }.to raise_error(Berkshelf::ArgumentError, "Cannot specify both :except and :only")
-      end
+      expect(subject).to receive(:retrieve_locked).twice
+      subject.cookbooks
     end
   end
 
@@ -338,7 +304,7 @@ describe Berkshelf::Berksfile do
   end
 
   describe '#retrieve_locked' do
-    let(:lockfile) { double('lockfile', find: locked) }
+    let(:lockfile) { double('lockfile') }
     let(:dependency) { double('dependency', name: 'bacon') }
     let(:locked) { double('locked', cached_cookbook: cached, locked_version: '1.0.0') }
     let(:cached) { double('cached') }
@@ -347,18 +313,9 @@ describe Berkshelf::Berksfile do
       subject.stub(:lockfile).and_return(lockfile)
     end
 
-    it 'raises an error when the lockfile does not have the source' do
-      lockfile.stub(:find)
-      expect {
-        subject.retrieve_locked(dependency)
-      }.to raise_error(Berkshelf::CookbookNotFound)
-    end
-
-    it 'raises an error when the cookbook is not downloaded' do
-      locked.stub(:downloaded?).and_return(false)
-      expect {
-        subject.retrieve_locked(dependency)
-      }.to raise_error(Berkshelf::CookbookNotFound)
+    it 'delegates to the lockfile' do
+      expect(lockfile).to receive(:retrieve).with(dependency)
+      subject.retrieve_locked(dependency)
     end
   end
 

data/spec/unit/berkshelf/cookbook_generator_spec.rb

@@ -46,6 +46,10 @@ describe Berkshelf::CookbookGenerator do
           contains '    "recipe[sparkle_motion::default]"'
           contains 'Author:: YOUR_NAME (<YOUR_EMAIL>)'
         end
+        file 'CHANGELOG.md' do
+          contains '# sparkle_motion cookbook CHANGELOG'
+          contains "## v0.1.0 (#{Time.now.strftime('%Y-%m-%d')})"
+        end
         file 'metadata.rb' do
           contains "name             'sparkle_motion'"
           contains "maintainer       'YOUR_NAME'"

data/spec/unit/berkshelf/installer_spec.rb

@@ -1,12 +1,13 @@
 require 'spec_helper'
 
 describe Berkshelf::Installer do
-  let(:berksfile) { double('berksfile') }
+  let(:berksfile) { double('berksfile', lockfile: lockfile) }
+  let(:lockfile) { double('lockfile') }
   subject { described_class.new(berksfile) }
 
   describe "#build_universe" do
-    let(:source_one) { double('one') }
-    let(:source_two) { double('two') }
+    let(:source_one) { double('one', uri: 'https://api.berkshelf.com') }
+    let(:source_two) { double('two', uri: 'https://api.chef.org') }
     let(:sources) { [ source_one, source_two ] }
 
     before { berksfile.stub(sources: sources) }
@@ -32,8 +33,4 @@ describe Berkshelf::Installer do
       pending
     end
   end
-
-  describe "#verify_licenses!" do
-    pending
-  end
 end

data/spec/unit/berkshelf/lockfile_parser_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe Berkshelf::Lockfile do
+  before do
+    subject.stub(:filepath).and_return(fixture) if defined?(fixture)
+    subject.parse
+  end
+
+  context 'with an old 2.0 lockfile format' do
+    let(:fixture) { fixtures_path.join('lockfiles/2.0.lock') }
+
+    it 'does not blow up' do
+      expect { subject }.to_not raise_error
+    end
+
+    it 'warns the user' do
+      expect(Berkshelf.ui).to receive(:warn)
+      subject.parse
+    end
+
+    it 'sets the dependencies' do
+      expect(subject).to have_dependency('apt')
+      expect(subject).to have_dependency('jenkins')
+      expect(subject).to have_dependency('runit')
+      expect(subject).to have_dependency('yum')
+
+      expect(subject.find('apt').version_constraint.to_s).to eq('>= 0.0.0')
+      expect(subject.find('jenkins').version_constraint.to_s).to eq('>= 0.0.0')
+      expect(subject.find('runit').version_constraint.to_s).to eq('>= 0.0.0')
+      expect(subject.find('yum').version_constraint.to_s).to eq('>= 0.0.0')
+    end
+
+    it 'sets the graph' do
+      graph = subject.graph
+
+      expect(graph).to have_lock('apt')
+      expect(graph).to have_lock('jenkins')
+      expect(graph).to have_lock('runit')
+      expect(graph).to have_lock('yum')
+
+      expect(graph.find('apt').version).to eq('2.3.6')
+      expect(graph.find('jenkins').version).to eq('2.0.3')
+      expect(graph.find('runit').version).to eq('1.5.8')
+      expect(graph.find('yum').version).to eq('3.0.6')
+    end
+  end
+
+  context 'with a blank lockfile' do
+    let(:fixture) { fixtures_path.join('lockfiles/blank.lock') }
+
+    it 'warns the user' do
+      expect(Berkshelf.ui).to receive(:warn)
+      subject.parse
+    end
+
+    it 'sets an empty list of dependencies' do
+      expect(subject.dependencies).to be_empty
+    end
+
+    it 'sets an empty graph' do
+      expect(subject.graph.locks).to be_empty
+    end
+  end
+
+  context 'with an empty lockfile' do
+    let(:fixture) { fixtures_path.join('lockfiles/empty.lock') }
+
+    it 'does not warn the user' do
+      expect(Berkshelf.ui).to_not receive(:warn)
+      subject.parse
+    end
+
+    it 'sets an empty list of dependencies' do
+      expect(subject.dependencies).to be_empty
+    end
+
+    it 'sets an empty graph' do
+      expect(subject.graph.locks).to be_empty
+    end
+  end
+
+  context 'with real lockfile' do
+    let(:fixture) { fixtures_path.join('lockfiles/default.lock') }
+
+    it 'sets the dependencies' do
+      expect(subject).to have_dependency('apt')
+      expect(subject).to have_dependency('jenkins')
+
+      expect(subject.find('apt').version_constraint.to_s).to eq('~> 2.0')
+      expect(subject.find('jenkins').version_constraint.to_s).to eq('~> 2.0')
+    end
+
+    it 'sets the graph' do
+      graph = subject.graph
+
+      expect(graph).to have_lock('apt')
+      expect(graph).to have_lock('build-essential')
+      expect(graph).to have_lock('jenkins')
+      expect(graph).to have_lock('runit')
+      expect(graph).to have_lock('yum')
+      expect(graph).to have_lock('yum-epel')
+
+      expect(graph.find('apt').version).to eq('2.3.6')
+      expect(graph.find('build-essential').version).to eq('1.4.2')
+      expect(graph.find('jenkins').version).to eq('2.0.3')
+      expect(graph.find('runit').version).to eq('1.5.8')
+      expect(graph.find('yum').version).to eq('3.0.6')
+      expect(graph.find('yum-epel').version).to eq('0.2.0')
+    end
+
+    it 'sets the graph item dependencies' do
+      jenkins = subject.graph.find('jenkins')
+      runit = subject.graph.find('runit')
+
+      expect(jenkins.dependencies).to include('apt' => '~> 2.0')
+      expect(jenkins.dependencies).to include('runit' => '~> 1.5')
+      expect(jenkins.dependencies).to include('yum' => '~> 3.0')
+
+      expect(runit.dependencies).to include('build-essential' => '>= 0.0.0')
+      expect(runit.dependencies).to include('yum' => '~> 3.0')
+      expect(runit.dependencies).to include('yum-epel' => '>= 0.0.0')
+    end
+  end
+end

data/spec/unit/berkshelf/lockfile_spec.rb

@@ -1,234 +1,211 @@
 require 'spec_helper'
 
 describe Berkshelf::Lockfile do
-  let!(:content) { File.read(fixtures_path.join('lockfiles/default.lock')) }
-  let(:berksfile) { Berkshelf::Berksfile.new('Berksfile') }
+  let(:filepath) { fixtures_path.join('lockfiles/default.lock').to_s }
+  subject { Berkshelf::Lockfile.new(filepath: filepath) }
 
-  before do
-    File.stub(:read).and_return(content)
-  end
+  describe '.initialize' do
+    subject { described_class.new(filepath: filepath) }
 
-  describe '::initialize' do
-    it 'does not throw an exception' do
-      expect {
-        Berkshelf::Lockfile.from_berksfile(berksfile)
-      }.to_not raise_error
+    it 'sets the instance variables' do
+      expect(subject.filepath).to eq(filepath)
+      expect(subject.dependencies).to be_a(Array)
+      expect(subject.graph).to be_a(Berkshelf::Lockfile::Graph)
     end
 
     it 'has the correct dependencies' do
-      expect(subject).to have_dependency 'build-essential'
-      expect(subject).to have_dependency 'chef-client'
+      expect(subject).to have_dependency('apt')
+      expect(subject).to have_dependency('jenkins')
     end
   end
 
-  subject { Berkshelf::Lockfile.from_berksfile(berksfile) }
-
-  describe "#apply" do
-    let(:env_name)    { 'berkshelf-test' }
-    let(:server_url)  { Berkshelf::RSpec::ChefServer.server_url }
-    let(:client_name) { 'berkshelf' }
-    let(:client_key)  {
-      "-----BEGIN RSA PRIVATE KEY-----
-MIIEpQIBAAKCAQEAs3u5qfmdEWtzYHvXpbQRyefhUjeTG7nwhn/LaYY6ou19xxW0
-I5MKSBqCxUCHqODRc7ox8zSF37x3jMBHbSczOcfbWsSe/qGnmvZZQhHmXCje2zkW
-ByaRHmmatzkz1aAqAmZm/wdSuVLXytsbrPXuaj/MiHa6QH3e/ZFaYME7rMkouqfC
-pUlSa2tZ9Ko1ZCCwjkiifuP4yQFsS6/G6b8c7F8wdq4byfJ9o6FN34lJHrzfG0ZV
-hwS47Bdn6FDBQ6PVxrBsvQNE2n7QlNLfXWi4Tb8OpmQif01FjxleAr5kamx3GD+s
-jC7fKHE9bZ0apZ1MVmkz9PhFmOigV5jl9Att+QIDAQABAoIBAQCCG6qXgQ9PVWkq
-BBxrToGmr6UzCH5nlv65QWKfeGKBQU/wRdd0Al9trWomu4Sb831iOxOCjgyOB/1R
-1wDwK36C4FIvFmF7jIwHVZWWw4sOO8JxgIxrWpXQShWRxLHCpnxNiRYYwaJCHb+4
-meUSGKVf+Ce4tPiHT7eacQfnI6yyr1hWusKu0I8w7NsfeNc+/Rpne6mifLfaB/9u
-b9kgfD15HGEsuUaMLZ/y1HFWvw2G2Og1cDrIpBIVtUAhA+DnjjLe/YoETeSmQAxH
-ioQpJJ/gSqtTczIoyPXXiwaF5wUTQrsn5zZhTs9mAQy7hcSR92IH2xBSmK3+wlz0
-vHZIq9rRAoGBAOeRUTRDgj+f+BlH1qFqf4EfkBN5quVM2808LYBGZWfA5/6o9jSN
-AM84VXq3S8Wy5V6UMcSv4mOqEr3tEUYE8or9r/RxzpGahSdi8Ttju9vvpJH5I3xr
-xx2ZK/vlrAfr6JHlE4bqqc5unCslUt2/liCWpERQ3cFcPydQb7Imrm+DAoGBAMZr
-mcxBeMyQHG6Kcpc7EQXZ5i7a8T6ksPu7FbAZ70Meb9UMtVIYpVBalutCXKhl7D4K
-qrCmV2gQryBz+S7AecFZSKvXdb7ueYzf8EcI/v+loNu9v9/4m4YV3bPBkMhW5kcK
-xFnVIsYqUlR+dsS8JfjSCpk4lePVSSt7B26eIFfTAoGBAJHPDKSuBWtunNe+RkUp
-O9PgPeYlbBgqBxT52WS17tAfxXSyiySXzHSuchRtKgb4GDkvcw73+MLsqhRxG7lN
-EDO4fXyb1IgWFdWxFVhh+j4IbUWE7HVBoAThF7Lq8SGjx7Nl3J/NTtKvDyKTw9Pg
-+PTYJeLmUFuabCGjIlG4zYllAoGBAIwe5oB4597GEl35xUyI+M+B/myuTtknIpjS
-mFFBL1bdwqnYjJ+KKgwhvRwsRBTjzT5O+BVBks45ogKwA5OBdzoUXB6GTG9mJ05V
-wm/XqYRNqdgkGsEG5oV9IZBUrHLd80bOErVBr4nzzyo+GI98MvCRG8zySd+X+lEL
-U8dJQZvjAoGAWorll+fomfie6t5XbkpwMo8rn60yFUiRE7HWxA2qDj3IpoE6SfNE
-eOpsf1Zzx30r8answ9lPnd753ACdgNzE66ScWD+cQeB6OlMZMaW5tVSjddZ7854L
-00znt8b1OLkVY33xfsa89wKH343304BhVHABPMxm5Leua/H21/BqSK0=
------END RSA PRIVATE KEY-----
-"
-    }
-    let(:ridley) { Ridley.new(server_url: server_url, client_name: client_name, client_key: client_key) }
+  describe '#parse' do
+    let(:parser) { double('parser', run: true) }
 
     before do
-      Berkshelf.stub(:ridley_connection).and_yield(ridley)
-      berksfile.add_dependency('nginx', '>= 0.1.2')
+      Berkshelf::Lockfile::LockfileParser.stub(:new).and_return(parser)
     end
 
-    context "when the chef environment exists" do
-      let(:dependencies) do
-        [
-          double(name: 'nginx', locked_version: '1.2.3'),
-          double(name: 'artifact', locked_version: '1.4.0')
-        ]
-      end
-
-      before do
-        chef_environment(env_name)
-        subject.stub(:dependencies).and_return(dependencies)
-      end
-
-      # it "test", focus: true do
-      #   p client_key
-      #   p File.read(client_key)
-      #   # p ridley.environment.find(env_name)
-      # end
-
-      it "applys the locked_versions of the Lockfile dependencies to the given Chef environment" do
-        subject.apply(env_name)
-
-        environment = ::JSON.parse(chef_server.data_store.get(['environments', env_name]))
-        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
+    it 'creates a new parser object' do
+      expect(Berkshelf::Lockfile::LockfileParser).to receive(:new).with(subject)
+      expect(parser).to receive(:run)
+      subject.parse
     end
 
-    context "when the environment does not exist" do
-      it "raises an EnvironmentNotFound error" do
-        expect {
-          subject.apply("not-there")
-        }.to raise_error(Berkshelf::EnvironmentNotFound)
-      end
+    it 'returns true (always)' do
+      expect(subject.parse).to be_true
     end
   end
 
-  describe '#dependencies' do
-    it 'returns an array' do
-      expect(subject.dependencies).to be_a(Array)
+  describe '#present?' do
+    it 'returns true when the file exists' do
+      expect(subject.present?).to be_true
     end
-  end
 
-  describe '#find' do
-    it 'returns a matching cookbook' do
-      expect(subject.find('build-essential').name).to eq 'build-essential'
+    it 'returns false when the file does not exist' do
+      File.stub(:exists?).and_return(false)
+      expect(subject.present?).to be_false
     end
 
-    it 'returns nil for a missing cookbook' do
-      expect(subject.find('foo')).to be_nil
+    it 'returns false when the file is empty' do
+      File.stub(:read).and_return('')
+      expect(subject.present?).to be_false
     end
   end
 
-  describe '#has_dependency?' do
-    it 'returns true if a matching cookbook is found' do
-      expect(subject.has_dependency?('build-essential')).to be_true
-    end
+  describe '#trusted?' do
+    it 'returns true when the lockfile is trusted' do
+      apt = double('apt',
+        version_constraint: Solve::Constraint.new('>= 0.0.0'),
+        version: '1.0.0',
+        location: 'api',
+      )
+      berksfile = double('berksfile', dependencies: [apt])
+      subject.instance_variable_set(:@berksfile, berksfile)
+      subject.stub(:find).with(apt).and_return(apt)
+      subject.graph.stub(:find).with(apt).and_return(apt)
 
-    it 'returns false if no matching cookbook is found' do
-      expect(subject.has_dependency?('foo')).to be_false
+      expect(subject.trusted?).to be_true
     end
-  end
 
-  describe '#update' do
-    it 'resets the dependencies' do
-      subject.should_receive(:reset_dependencies!).once
-      subject.update([])
-    end
+    it 'returns false if the dependency is not in the lockfile' do
+      apt = double('apt', version_constraint: nil)
+      berksfile = double('berksfile', dependencies: [apt])
+      subject.instance_variable_set(:@berksfile, berksfile)
 
-    it 'appends each of the dependencies' do
-      dependency = double('dependency')
-      subject.should_receive(:append).with(dependency).once
-      subject.update([dependency])
+      expect(subject.trusted?).to be_false
     end
 
-    it 'saves the file' do
-      subject.should_receive(:save).once
-      subject.update([])
+    it 'returns false if the dependency is not in the graph' do
+      apt = double('apt', version_constraint: nil)
+      berksfile = double('berksfile', dependencies: [apt])
+      subject.instance_variable_set(:@berksfile, berksfile)
+      subject.stub(:find).with(apt).and_return(true)
+      subject.graph.stub(:find).with(apt).and_return(false)
+
+      expect(subject.trusted?).to be_false
     end
-  end
 
-  describe '#add' do
-    let(:dependency) { double('dependency', name: 'build-essential') }
+    it 'returns false if the constraint is not satisfied' do
+      apt = double('apt',
+        version_constraint: Solve::Constraint.new('< 1.0.0'),
+        version: '1.0.0',
+        location: 'api'
+      )
+      berksfile = double('berksfile', dependencies: [apt])
+      subject.instance_variable_set(:@berksfile, berksfile)
+      subject.stub(:find).with(apt).and_return(apt)
+      subject.graph.stub(:find).with(apt).and_return(apt)
 
-    it 'adds the new dependency to the @dependencies instance variable' do
-      subject.add(dependency)
-      expect(subject).to have_dependency(dependency)
+      expect(subject.trusted?).to be_false
     end
 
-    it 'does not add duplicate dependencies' do
-      5.times { subject.add(dependency) }
-      expect(subject).to have_dependency(dependency)
+    it 'returns false if the locations are different' do
+      apt = double('apt',
+        version_constraint: Solve::Constraint.new('< 1.0.0'),
+        version: '1.0.0',
+        location: 'api'
+      )
+      apt_master = apt.dup
+      apt_master.stub(location: 'github')
+      berksfile = double('berksfile', dependencies: [apt])
+      subject.instance_variable_set(:@berksfile, berksfile)
+      subject.stub(:find).with(apt).and_return(apt_master)
+      subject.graph.stub(:find).with(apt).and_return(apt)
+
+      expect(subject.trusted?).to be_false
     end
   end
 
-  describe '#remove' do
-    let(:dependency) { double('dependency', name: 'build-essential') }
+  describe '#apply' do
+    let(:connection) { double('connection') }
 
     before do
-      subject.add(dependency)
+      Berkshelf.stub(:ridley_connection).and_yield(connection)
     end
 
-    it 'removes the dependency' do
-      subject.remove(dependency)
-      expect(subject).to_not have_dependency(dependency)
+    context 'when the Chef environment does not exist' do
+      it 'raises an exception' do
+        connection.stub(:environment).and_return(double(find: nil))
+        expect {
+          subject.apply('production')
+        }.to raise_error(Berkshelf::EnvironmentNotFound)
+      end
     end
 
-    it 'raises an except if the dependency does not exist' do
-      expect {
-        subject.remove(nil)
-      }.to raise_error Berkshelf::CookbookNotFound
+    it 'locks the environment cookbook versions' do
+      apt = double(name: 'apt', locked_version: '1.0.0')
+      jenkins = double(name: 'jenkins', locked_version: '1.4.5')
+      subject.graph.stub(:locks).and_return('apt' => apt, 'jenkins' => jenkins)
+
+      environment = double('environment', :cookbook_versions= => nil, save: true)
+      connection.stub(:environment).and_return(double(find: environment))
+
+      expect(environment).to receive(:cookbook_versions=).with(
+        'apt' => '= 1.0.0',
+        'jenkins' => '= 1.4.5',
+      )
+
+      subject.apply('production')
     end
   end
 
-  describe '#to_hash' do
-    let(:hash) { subject.to_hash }
-
-    it 'has the `:dependencies` key' do
-      expect(hash).to have_key(:dependencies)
+  describe '#dependencies' do
+    it 'returns an array' do
+      expect(subject.dependencies).to be_a(Array)
     end
   end
 
-  describe '#to_json' do
-    it 'dumps the #to_hash to JSON' do
-      JSON.should_receive(:pretty_generate).with(subject.to_hash, {})
-      subject.to_json
+  describe '#find' do
+    it 'returns a matching cookbook' do
+      expect(subject.find('apt').name).to eq('apt')
+    end
+
+    it 'returns nil for a missing cookbook' do
+      expect(subject.find('foo')).to be_nil
     end
   end
 
-  describe '#save' do
-    before { Berkshelf::Lockfile.send(:public, :save) }
-    let(:file) { double('file') }
+  describe '#has_dependency?' do
+    it 'returns true if a matching cookbook is found' do
+      expect(subject).to have_dependency('apt')
+    end
 
-    before(:each) do
-      File.stub(:open).with('Berksfile.lock', 'w')
+    it 'returns false if no matching cookbook is found' do
+      expect(subject).to_not have_dependency('foo')
     end
+  end
 
-    it 'saves itself to a file on disk' do
-      File.should_receive(:open).with(/(.+)\/Berksfile\.lock/, 'w').and_yield(file)
-      file.should_receive(:write).once
-      subject.save
+  describe '#add' do
+    it 'adds the dependency to the lockfile' do
+      subject.add('apache2')
+      expect(subject).to have_dependency('apache2')
     end
   end
 
-  describe '#reset_dependencies!' do
-    before { Berkshelf::Lockfile.send(:public, :reset_dependencies!) }
+  describe '#update' do
+    it 'resets the dependencies' do
+      subject.update([])
+      expect(subject.dependencies).to be_empty
+    end
 
-    it 'sets the dependencies to an empty hash' do
-      expect {
-        subject.reset_dependencies!
-      }.to change { subject.dependencies }.to([])
+    it 'appends each of the dependencies' do
+      subject.update(['apache2'])
+      expect(subject).to have_dependency('apache2')
     end
   end
 
-  describe '#cookbook_name' do
-    before { Berkshelf::Lockfile.send(:public, :cookbook_name) }
-
-    it 'accepts a cookbook dependency' do
-      dependency = double('dependency', name: 'build-essential', is_a?: true)
-      expect(subject.cookbook_name(dependency)).to eq 'build-essential'
+  describe '#unlock' do
+    it 'raises an exception when the dependency does not exist' do
+      expect {
+        subject.unlock('foo')
+      }.to raise_error(Berkshelf::CookbookNotFound)
     end
 
-    it 'accepts a string' do
-      expect(subject.cookbook_name('build-essential')).to eq 'build-essential'
+    it 'removes the dependency from the graph' do
+      subject.add('apache2')
+      subject.unlock('apache2')
+      expect(subject).to_not have_dependency('apache2')
     end
   end
 end