berkshelf 3.0.0.beta3 → 3.0.0.beta4

data/lib/berkshelf/locations/path_location.rb

@@ -1,24 +1,5 @@
 module Berkshelf
   class PathLocation < Location::Base
-    class << self
-      # Expand and return a string representation of the given path if it is
-      # absolute or a path in the users home directory.
-      #
-      # Returns the given relative path otherwise.
-      #
-      # @param [#to_s] path
-      #
-      # @return [String]
-      def normalize_path(path)
-        path = path.to_s
-        if (path[0] == '~') || Pathname.new(path).absolute?
-          File.expand_path(path)
-        else
-          path
-        end
-      end
-    end
-
     set_location_key :path
     set_valid_options :path, :metadata
 

data/lib/berkshelf/lockfile.rb

@@ -5,6 +5,29 @@ module Berkshelf
   # when working in teams where the same cookbook versions are desired across
   # multiple workstations.
   class Lockfile
+    class << self
+      # Initialize a Lockfile from the given filepath
+      #
+      # @param [String] filepath
+      #   filepath to the lockfile
+      def from_file(filepath)
+        new(filepath: filepath)
+      end
+
+      # Initialize a Lockfile from the given Berksfile
+      #
+      # @param [Berkshelf::Berksfile] berksfile
+      #   the Berksfile associated with the Lockfile
+      def from_berksfile(berksfile)
+        filepath = File.join(File.dirname(File.expand_path(berksfile.filepath)), Lockfile::DEFAULT_FILENAME)
+        new(berksfile: berksfile, filepath: filepath)
+      end
+    end
+
+    DEFAULT_FILENAME = "Berksfile.lock"
+
+    include Berkshelf::Mixin::Logging
+
     # @return [Pathname]
     #   the path to this Lockfile
     attr_reader :filepath
@@ -17,16 +40,55 @@ module Berkshelf
     # Lockfile exists, it is automatically loaded. Otherwise, an empty instance is
     # created and ready for use.
     #
-    # @param berksfile [Berkshelf::Berksfile]
+    # @option options [String] :filepath
+    #   filepath to the lockfile
+    # @option options [Berkshelf::Berksfile] :berksfile
     #   the Berksfile associated with this Lockfile
-    def initialize(berksfile)
-      @berksfile    = berksfile
-      @filepath     = File.expand_path("#{berksfile.filepath}.lock")
+    def initialize(options = {})
+      @filepath     = options[:filepath].to_s
+      @berksfile    = options[:berksfile]
       @dependencies = {}
 
       load! if File.exists?(@filepath)
     end
 
+    # Resolve this Berksfile and apply the locks found in the generated Berksfile.lock to the
+    # target Chef environment
+    #
+    # @param [String] environment_name
+    #
+    # @option options [Hash] :ssl_verify (true)
+    #   Disable/Enable SSL verification during uploads
+    #
+    # @raise [EnvironmentNotFound]
+    #   if the target environment was not found
+    # @raise [ChefConnectionError]
+    #   if you are locking cookbooks with an invalid or not-specified client configuration
+    def apply(environment_name, options = {})
+      Berkshelf.ridley_connection(options) do |conn|
+        unless environment = conn.environment.find(environment_name)
+          raise EnvironmentNotFound.new(environment_name)
+        end
+
+        environment.cookbook_versions = {}.tap do |cookbook_versions|
+          dependencies.each do |dependency|
+            if dependency.locked_version.nil?
+              # A locked version must be present for each entry. Older versions of the lockfile
+              # may have contained dependencies with a special type of location that would attempt
+              # to dynamically determine the locked version. This is incorrect and the Lockfile
+              # should be regenerated if that is the case.
+              raise InvalidLockFile, "Your lockfile contains a dependency without a locked version. This " +
+                "may be because you have an old lockfile. Regenerate your lockfile and try again."
+            end
+
+            cookbook_versions[dependency.name] = "= #{dependency.locked_version.to_s}"
+          end
+        end
+
+        environment.save
+      end
+    end
+
     # Load the lockfile from file system.
     def load!
       contents = File.read(filepath).strip

data/lib/berkshelf/mixin/logging.rb

@@ -5,7 +5,7 @@ module Berkshelf
         Berkshelf::Logger
       end
 
-      # Log an exception and it's backtrace to FATAL
+      # Log an exception and its backtrace to FATAL
       #
       # @param [Exception] ex
       def log_exception(ex)

data/lib/berkshelf/version.rb

@@ -1,3 +1,3 @@
 module Berkshelf
-  VERSION = "3.0.0.beta3"
+  VERSION = "3.0.0.beta4"
 end

data/spec/spec_helper.rb

@@ -1,9 +1,13 @@
 require 'spork'
 
+def windows?
+  !!(RUBY_PLATFORM =~ /mswin|mingw|windows/)
+end
+
 Spork.prefork do
   require 'rspec'
   require 'webmock/rspec'
-  require 'berkshelf/api/rspec'
+  require 'berkshelf/api/rspec' unless windows?
 
   Dir['spec/support/**/*.rb'].each { |f| require File.expand_path(f) }
 
@@ -13,7 +17,7 @@ Spork.prefork do
     config.include Berkshelf::RSpec::ChefServer
     config.include Berkshelf::RSpec::Git
     config.include Berkshelf::RSpec::PathHelpers
-    config.include Berkshelf::API::RSpec
+    config.include Berkshelf::API::RSpec unless windows?
 
     config.expect_with :rspec do |c|
       c.syntax = :expect
@@ -27,7 +31,7 @@ Spork.prefork do
     config.before(:suite) do
       WebMock.disable_net_connect!(allow_localhost: true, net_http_connect_on_start: true)
       Berkshelf::RSpec::ChefServer.start
-      Berkshelf::API::RSpec::Server.start
+      Berkshelf::API::RSpec::Server.start unless windows?
       Berkshelf.set_format(:null)
       Berkshelf.ui.mute!
     end
@@ -41,7 +45,7 @@ Spork.prefork do
     end
 
     config.before(:each) do
-      Berkshelf::API::RSpec::Server.clear_cache
+      Berkshelf::API::RSpec::Server.clear_cache unless windows?
       clean_tmp_path
       Berkshelf.initialize_filesystem
       Berkshelf::CookbookStore.instance.initialize_filesystem

data/spec/support/git.rb

@@ -21,23 +21,23 @@ module Berkshelf
 
           Dir.chdir(path) do
             shell_out "git config receive.denyCurrentBranch ignore"
-            shell_out "echo '# a change!' >> content_file"
+            shell_out "echo \"# a change!\" >> content_file"
             shell_out "git add ."
-            shell_out "git commit -am 'A commit.'"
+            shell_out "git commit -am \"A commit.\""
 
             options[:tags].each do |tag|
-              shell_out "echo '#{tag}' > content_file"
+              shell_out "echo \"#{tag}\" > content_file"
               shell_out "git add content_file"
-              shell_out "git commit -am '#{tag} content'"
-              shell_out "git tag '#{tag}' 2> /dev/null"
+              shell_out "git commit -am \"#{tag} content\""
+              shell_out "git tag \"#{tag}\""
             end if options[:tags]
 
             options[:branches].each do |branch|
-              shell_out "git checkout -b #{branch} master 2> /dev/null"
-              shell_out "echo '#{branch}' > content_file"
+              shell_out "git checkout -b #{branch} master"
+              shell_out "echo \"#{branch}\" > content_file"
               shell_out "git add content_file"
-              shell_out "git commit -am '#{branch} content'"
-              shell_out "git checkout master 2> /dev/null"
+              shell_out "git commit -am \"#{branch} content\""
+              shell_out "git checkout master"
             end if options[:branches]
           end
         end

data/spec/support/mercurial.rb

@@ -8,7 +8,7 @@ module Berkshelf
       include Berkshelf::RSpec::PathHelpers
 
       def mercurial_origin_for(repo, options = {})
-        "file://localhost#{generate_fake_mercurial_remote(repo, options)}"
+        File.join("file://localhost", generate_fake_mercurial_remote(repo, options))
       end
 
       def generate_fake_mercurial_remote(uri, options = {})
@@ -19,21 +19,21 @@ module Berkshelf
         Dir.chdir(repo_path) do
           ENV['HGUSER'] = 'test_user'
           shell_out "hg init"
-          shell_out "echo '# a change!' >> content_file"
+          shell_out "echo \"# a change!\" >> content_file"
           if options[:is_cookbook]
-            shell_out "echo '#cookbook' >> metadata.rb"
+            shell_out "echo \"#cookbook\" >> metadata.rb"
           end
           shell_out "hg add ."
-          shell_out "hg commit -m 'A commit.'"
+          shell_out "hg commit -m \"A commit.\""
           options[:tags].each do |tag|
-            shell_out "echo '#{tag}' > content_file"
-            shell_out "hg commit -m '#{tag} content'"
-            shell_out "hg tag '#{tag}'"
+            shell_out "echo \"#{tag}\" > content_file"
+            shell_out "hg commit -m \"#{tag} content\""
+            shell_out "hg tag \"#{tag}\""
           end if options.has_key? :tags
           options[:branches].each do |branch|
             shell_out "hg branch #{branch}"
-            shell_out "echo '#{branch}' > content_file"
-            shell_out "hg commit -m '#{branch} content'"
+            shell_out "echo \"#{branch}\" > content_file"
+            shell_out "hg commit -m \"#{branch} content\""
             shell_out "hg up default"
           end if options.has_key? :branches
         end

data/spec/unit/berkshelf/api_client_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Berkshelf::APIClient do
+describe Berkshelf::APIClient, :api_client do
   let(:instance) { described_class.new("http://localhost:26210") }
 
   describe "#universe" do

data/spec/unit/berkshelf/berksfile_spec.rb

@@ -68,7 +68,13 @@ describe Berkshelf::Berksfile do
     end
 
     it 'merges the default options into specified options' do
-      subject.should_receive(:add_dependency).with(name, constraint, path: '/Users/reset', group: [])
+      subject.should_receive(:add_dependency)do |arg_name, arg_constraint, arg_options|
+        expect(arg_name).to eq(name)
+        expect(arg_constraint).to eq(constraint)
+        expect(arg_options[:path]).to match(%r{/Users/reset})
+        expect(arg_options[:group]).to eq([])
+      end
+
       subject.cookbook(name, constraint, path: '/Users/reset')
     end
 
@@ -333,30 +339,25 @@ describe Berkshelf::Berksfile do
 
   describe '#retrieve_locked' do
     let(:lockfile) { double('lockfile', find: locked) }
+    let(:dependency) { double('dependency', name: 'bacon') }
     let(:locked) { double('locked', cached_cookbook: cached, locked_version: '1.0.0') }
     let(:cached) { double('cached') }
 
     before do
-      subject.stub(:validate_cookbook_names!)
       subject.stub(:lockfile).and_return(lockfile)
     end
 
-    it 'validates cookbook names' do
-      expect(subject).to receive(:validate_cookbook_names!).once
-      subject.retrieve_locked('bacon')
-    end
-
-    it 'raises an error when the lockfile does not exist' do
+    it 'raises an error when the lockfile does not have the source' do
       lockfile.stub(:find)
       expect {
-        subject.retrieve_locked('bacon')
-      }.to raise_error(Berkshelf::LockfileNotFound)
+        subject.retrieve_locked(dependency)
+      }.to raise_error(Berkshelf::CookbookNotFound)
     end
 
     it 'raises an error when the cookbook is not downloaded' do
-      locked.stub(:cached_cookbook)
+      locked.stub(:downloaded?).and_return(false)
       expect {
-        subject.retrieve_locked('bacon')
+        subject.retrieve_locked(dependency)
       }.to raise_error(Berkshelf::CookbookNotFound)
     end
   end
@@ -483,54 +484,30 @@ describe Berkshelf::Berksfile do
         upload
       end
     end
-  end
-
-  describe "#apply" do
-    let(:env_name)    { 'berkshelf-test' }
-    let(:server_url)  { Berkshelf::RSpec::ChefServer.server_url }
-    let(:client_name) { 'berkshelf' }
-    let(:client_key)  { fixtures_path.join('../config/berkshelf.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_yield(ridley)
-      subject.add_dependency('nginx', '>= 0.1.2')
-      subject.stub(install: nil)
-    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('berkshelf')
-        subject.lockfile.stub(:dependencies).and_return(dependencies)
-      end
-
-      it 'installs the Berksfile' do
-        subject.should_receive(:install)
-        subject.apply('berkshelf')
+    context 'when validate is passed' do
+      let(:options) do
+        {
+          force: false,
+          freeze: true,
+          validate: false,
+          name: "cookbook"
+        }
       end
-
-      it 'applys the locked_versions of the Lockfile dependencies to the given Chef environment' do
-        subject.apply('berkshelf')
-
-        environment = ::JSON.parse(chef_server.data_store.get(['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')
+      let(:ridley_options) do
+        default_ridley_options.merge(
+            { server_url: 'http://configured-chef-server/'})
       end
-    end
+      let(:cookbook) { double('cookbook', cookbook_name: 'cookbook', path: 'path', version: '1.0.0') }
+      let(:installed_cookbooks) { [ cookbook ] }
+      let(:cookbook_resource) { double('cookbook') }
+      let(:conn) { double('conn') }
 
-    context 'when the environment does not exist' do
-      it 'raises an EnvironmentNotFound error' do
-        expect {
-          subject.apply(env_name)
-        }.to raise_error(Berkshelf::EnvironmentNotFound)
+      it 'uses the passed in :validate' do
+        Ridley.should_receive(:open).with(ridley_options).and_yield(conn)
+        conn.should_receive(:cookbook).and_return(cookbook_resource)
+        cookbook_resource.should_receive(:upload).with('path', options )
+        upload
       end
     end
   end
@@ -539,7 +516,7 @@ describe Berkshelf::Berksfile do
     context 'when the dependency does not exist' do
       it 'raises a CookbookNotFound exception' do
         expect {
-          subject.package('non-existent', output: '/tmp')
+          subject.package('non-existent', output: Dir.tmpdir)
         }.to raise_error(Berkshelf::CookbookNotFound)
       end
     end
@@ -547,7 +524,7 @@ describe Berkshelf::Berksfile do
     context 'when the dependency exists' do
       let(:dependency) { double('dependency') }
       let(:cached) { double('cached', path: '/foo/bar', cookbook_name: 'cookbook') }
-      let(:options) { { output: '/tmp' } }
+      let(:options) { { output: Dir.tmpdir } }
 
       before do
         FileUtils.stub(:cp_r)
@@ -562,7 +539,7 @@ describe Berkshelf::Berksfile do
       end
 
       it 'returns the output path' do
-        expect(subject.package('non-existent', options)).to eq('/tmp/non-existent.tar.gz')
+        expect(subject.package('non-existent', options)).to eq(File.join(Dir.tmpdir, 'non-existent.tar.gz'))
       end
     end
   end

data/spec/unit/berkshelf/cli_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Berkshelf::Cli do
+  let(:subject) { described_class.new }
+  let(:berksfile) { double('Berksfile') }
+  let(:cookbooks) { ['mysql'] }
+  describe '#upload' do
+    it 'calls to upload with params if passed in cli' do
+      Berkshelf::Berksfile.should_receive(:from_file).and_return(berksfile)
+      berksfile.should_receive(:upload).with(include(:skip_syntax_check => true, :freeze => false, :cookbooks => cookbooks))
+      subject.options[:skip_syntax_check] = true
+      subject.options[:no_freeze] = true
+      subject.upload('mysql')
+    end
+  end
+end

data/spec/unit/berkshelf/config_spec.rb

@@ -37,7 +37,7 @@ describe Berkshelf::Config do
       end
 
       it "points to a location within it" do
-        expect(Berkshelf::Config.path).to eq('/tmp/config.json')
+        expect(Berkshelf::Config.path).to match(%r{/tmp/config.json})
       end
     end
   end

data/spec/unit/berkshelf/cookbook_generator_spec.rb

@@ -39,13 +39,11 @@ describe Berkshelf::CookbookGenerator do
           contains 'All rights reserved - Do Not Redistribute'
         end
         file 'README.md' do
-          contains 'sparkle_motion cookbook'
-          contains '======================='
-          contains '- `toaster` - sparkle_motion needs toaster to brown your bagel.'
-          contains '#### sparkle_motion::default'
+          contains '# sparkle_motion-cookbook'
+          contains '### sparkle_motion::default'
           contains "    <td><tt>['sparkle_motion']['bacon']</tt></td>"
-          contains "Just include `sparkle_motion` in your node's `run_list`:"
-          contains '    "recipe[sparkle_motion]"'
+          contains "Include `sparkle_motion` in your node's `run_list`:"
+          contains '    "recipe[sparkle_motion::default]"'
           contains 'Author:: YOUR_NAME (<YOUR_EMAIL>)'
         end
         file 'metadata.rb' do