berkshelf 3.0.0.beta9 → 3.0.0.rc1

data/lib/berkshelf/logger.rb

@@ -11,8 +11,8 @@ module Berkshelf
     #
     # @param [Exception] ex
     def exception(ex)
-      log.fatal("#{ex.class}: #{ex}")
-      log.fatal(ex.backtrace.join("\n")) unless ex.backtrace.nil?
+      fatal("#{ex.class}: #{ex}")
+      fatal(ex.backtrace.join("\n")) unless ex.backtrace.nil?
     end
   end
 end

data/lib/berkshelf/resolver.rb

@@ -57,7 +57,10 @@ module Berkshelf
     #
     # @return [Array<String, String>]
     def demand_array
-      demands.collect { |demand| [ demand.name, demand.version_constraint ] }
+      demands.collect do |demand|
+        constraint = demand.locked_version || demand.version_constraint
+        [demand.name, constraint]
+      end
     end
 
     # Finds a solution for the currently added dependencies and their dependencies and

data/lib/berkshelf/uploader.rb

@@ -0,0 +1,122 @@
+module Berkshelf
+  class Uploader
+    attr_reader :berksfile
+    attr_reader :lockfile
+    attr_reader :options
+    attr_reader :names
+
+    def initialize(berksfile, *args)
+      @berksfile = berksfile
+      @lockfile  = berksfile.lockfile
+
+      @options = {
+        force:          false,
+        freeze:         true,
+        halt_on_frozen: false,
+        validate:       true,
+      }.merge(args.last.is_a?(Hash) ? args.pop : {})
+
+      @names = Array(args).flatten
+    end
+
+    def run
+      Berkshelf.log.info "Uploading cookbooks"
+
+      cookbooks = if names.empty?
+                    Berkshelf.log.debug "  No names given, using all cookbooks"
+                    filtered_cookbooks
+                  else
+                    Berkshelf.log.debug "  Names given (#{names.join(', ')})"
+                    names.map { |name| lockfile.retrieve(name) }
+                  end
+
+      # Perform all validations first to prevent partially uploaded cookbooks
+      cookbooks.each { |cookbook| validate_files!(cookbook) }
+
+      upload(cookbooks)
+      cookbooks
+    end
+
+    private
+
+      # Upload the list of cookbooks to the Chef Server, with some exception
+      # wrapping.
+      #
+      # @param [Array<String>] cookbooks
+      def upload(cookbooks)
+        Berkshelf.log.info "Starting upload"
+
+        Berkshelf.ridley_connection(options) do |connection|
+          cookbooks.each do |cookbook|
+            Berkshelf.log.debug "  Uploading #{cookbook}"
+
+            begin
+              connection.cookbook.upload(cookbook.path,
+                name:     cookbook.cookbook_name,
+                force:    options[:force],
+                freeze:   options[:freeze],
+                validate: options[:validate],
+              )
+
+              Berkshelf.formatter.uploaded(cookbook, connection)
+            rescue Ridley::Errors::FrozenCookbook
+              if options[:halt_on_frozen]
+                raise FrozenCookbook.new(cookbook)
+              end
+
+              Berkshelf.formatter.skipping(cookbook, connection)
+            end
+          end
+        end
+      end
+
+      # Filter cookbooks based off the list of dependencies in the Berksfile.
+      #
+      # This method is secretly recursive. It iterates over each dependency in
+      # the Berksfile (using {Berksfile#dependencies} to account for filters)
+      # and retrieves that cookbook, it's dependencies, and the recusive
+      # dependencies, but iteratively.
+      #
+      # @return [Array<CachedCookbook>]
+      #
+      def filtered_cookbooks
+        # Create a copy of the dependencies. We need to make a copy, or else
+        # we would be adding dependencies directly to the Berksfile object, and
+        # that would be a bad idea...
+        dependencies = berksfile.dependencies.map(&:name)
+
+        checked   = {}
+        cookbooks = {}
+
+        dependencies.each do |dependency|
+          next if checked[dependency]
+
+          lockfile.graph.find(dependency).dependencies.each do |name, _|
+            cookbooks[name] ||= lockfile.retrieve(name)
+            dependencies << name
+          end
+
+          checked[dependency] = true
+          cookbooks[dependency] ||= lockfile.retrieve(dependency)
+        end
+
+        cookbooks.values.sort
+      end
+
+      # Validate that the given cookbook does not have "bad" files. Currently
+      # this means including spaces in filenames (such as recipes)
+      #
+      # @param [CachedCookbook] cookbook
+      #  the Cookbook to validate
+      def validate_files!(cookbook)
+        path = cookbook.path.to_s
+
+        files = Dir.glob(File.join(path, '**', '*.rb')).select do |f|
+          parent = Pathname.new(path).dirname.to_s
+          f.gsub(parent, '') =~ /[[:space:]]/
+        end
+
+        raise InvalidCookbookFiles.new(cookbook, files) unless files.empty?
+      end
+  end
+end

data/lib/berkshelf/version.rb

@@ -1,3 +1,3 @@
 module Berkshelf
-  VERSION = '3.0.0.beta9'
+  VERSION = '3.0.0.rc1'
 end

data/spec/unit/berkshelf/berksfile_spec.rb

@@ -320,187 +320,36 @@ describe Berkshelf::Berksfile do
   end
 
   describe '#upload' do
-    let(:graph)    { double(locks: []) }
-    let(:lockfile) { double(present?: true, trusted?: true, graph: graph) }
+    let(:uploader) { double(Berkshelf::Uploader, run: nil) }
 
     before do
-      Berkshelf.stub(:config).and_return(berkshelf_config)
-      subject.stub(:lockfile).and_return(lockfile)
-    end
-
-    let(:options) { Hash.new }
-    let(:chef_config) do
-      double('chef-config',
-        node_name: 'fake-client',
-        client_key: 'client-key',
-        chef_server_url: 'http://configured-chef-server/',
-        validation_client_name: 'validator',
-        validation_key: 'validator.pem',
-        cookbook_copyright: 'user',
-        cookbook_email: 'user@example.com',
-        cookbook_license: 'apachev2',
-      )
-    end
-    let(:berkshelf_config) { double('berkshelf-config', ssl: double(verify: true), chef: chef_config) }
-    let(:default_ridley_options) do
-      {
-        client_name: 'fake-client',
-        client_key: 'client-key',
-        ssl: {
-          verify: true
-        }
-      }
-    end
-
-    let(:upload) { subject.upload(options) }
-
-    context 'when there is no value for :chef_server_url' do
-      before { chef_config.stub(chef_server_url: nil) }
-      let(:message) { 'Missing required attribute in your Berkshelf configuration: chef.server_url' }
-
-      it 'raises an error' do
-        expect { upload }.to raise_error(Berkshelf::ChefConnectionError, message)
-      end
-    end
-
-    context 'when there is no value for :client_name' do
-      before { chef_config.stub(node_name: nil) }
-      let(:message) { 'Missing required attribute in your Berkshelf configuration: chef.node_name' }
-
-      it 'raises an error' do
-        expect { upload }.to raise_error(Berkshelf::ChefConnectionError, message)
-      end
-    end
-
-    context 'when there is no value for :client_key' do
-      before { chef_config.stub(client_key: nil) }
-      let(:message) { 'Missing required attribute in your Berkshelf configuration: chef.client_key' }
-
-      it 'raises an error' do
-        expect {
-          upload
-        }.to raise_error(Berkshelf::ChefConnectionError, message)
-      end
-    end
-
-    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)
-      end
-
-      it 'uses Berkshelf::Config configured server_url' do
-        Ridley.should_receive(:open).with(ridley_options)
-        upload
-      end
-    end
-
-    context 'when a Chef Server url is passed as an option' do
-      let(:options) do
-        {
-          server_url: 'http://fake-chef-server.com/'
-        }
-      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
-        Ridley.should_receive(:open).with(ridley_options)
-        upload
-      end
-    end
-
-    context 'when a client name is passed as an option' do
-      let(:options) do
-        {
-            client_name: 'passed-in-client-name'
-        }
-      end
-      let(:ridley_options) do
-        default_ridley_options.merge(
-            { server_url: 'http://configured-chef-server/', client_name: 'passed-in-client-name'})
-      end
-
-      it 'uses the passed in :client_name' do
-        Ridley.should_receive(:open).with(ridley_options)
-        upload
-      end
-    end
-
-    context 'when a client key is passed as an option' do
-      let(:options) do
-        {
-            client_key: 'passed-in-client-key'
-        }
-      end
-      let(:ridley_options) do
-        default_ridley_options.merge(
-            { server_url: 'http://configured-chef-server/', client_key: 'passed-in-client-key'})
-      end
+      subject.stub(:validate_lockfile_present!)
+      subject.stub(:validate_lockfile_trusted!)
+      subject.stub(:validate_dependencies_installed!)
 
-      it 'uses the passed in :client_key' do
-        Ridley.should_receive(:open).with(ridley_options)
-        upload
-      end
+      Berkshelf::Uploader.stub(:new).and_return(uploader)
     end
 
-    context 'when validate is passed' do
-      let(:mysql_dependency) { double(name: 'mysql', metadata?: false, dependencies: []) }
-      let(:mysql_cookbook)   { double(cookbook_name: 'mysql', path: 'path') }
-
-      let(:options) do
-        {
-          force:    false,
-          freeze:   true,
-          validate: false,
-          name:     mysql_cookbook.cookbook_name
-        }
-      end
-      let(:ridley_options) do
-        default_ridley_options.merge({ server_url: 'http://configured-chef-server/'})
-      end
-      let(:conn) { double('conn') }
-
-      before do
-        subject.stub(:dependencies).and_return([mysql_dependency])
-        graph.stub(:find).with(mysql_dependency).and_return(mysql_dependency)
-        lockfile.stub(:retrieve).with(mysql_dependency).and_return(mysql_cookbook)
-      end
-
-      it 'uses the passed in :validate' do
-        expect(Ridley).to receive(:open).and_yield(conn)
-        expect(conn).to receive(:cookbook).and_return(mysql_cookbook)
-        expect(mysql_cookbook).to receive(:upload).with('path', options)
-        subject.upload('mysql', options)
-      end
+    it 'validates the lockfile is present' do
+      expect(subject).to receive(:validate_lockfile_present!).once
+      subject.upload
     end
-  end
-
-  describe '#validate_files!' do
-    before { described_class.send(:public, :validate_files!) }
-    let(:cookbook) { double('cookbook', cookbook_name: 'cookbook', path: 'path') }
 
-    it 'raises an error when the cookbook has spaces in the files' do
-      Dir.stub(:glob).and_return(['/there are/spaces/in this/recipes/default.rb'])
-      expect {
-        subject.validate_files!(cookbook)
-      }.to raise_error
+    it 'validates the lockfile is trusted' do
+      expect(subject).to receive(:validate_lockfile_trusted!).once
+      subject.upload
     end
 
-    it 'does not raise an error when the cookbook is valid' do
-      Dir.stub(:glob).and_return(['/there-are/no-spaces/in-this/recipes/default.rb'])
-      expect {
-        subject.validate_files!(cookbook)
-      }.to_not raise_error
+    it 'validates the dependencies are installed' do
+      expect(subject).to receive(:validate_dependencies_installed!).once
+      subject.upload
     end
 
-    it 'does not raise an exception with spaces in the path' do
-      Dir.stub(:glob).and_return(['/there are/spaces/in this/recipes/default.rb'])
-      Pathname.any_instance.stub(:dirname).and_return('/there are/spaces/in this')
+    it 'creates a new Uploader' do
+      expect(Berkshelf::Uploader).to receive(:new).with(subject)
+      expect(uploader).to receive(:run)
 
-      expect {
-        subject.validate_files!(cookbook)
-      }.to_not raise_error
+      subject.upload
     end
   end
 end

data/spec/unit/berkshelf/cookbook_generator_spec.rb

@@ -47,8 +47,8 @@ describe Berkshelf::CookbookGenerator do
           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')})"
+          contains '# 0.1.0'
+          contains "Initial release of sparkle_motion"
         end
         file 'metadata.rb' do
           contains "name             'sparkle_motion'"

data/spec/unit/berkshelf/formatters/base_spec.rb

@@ -16,7 +16,7 @@ module Berkshelf
       }.to raise_error(AbstractFunction)
 
       expect {
-        subject.upload('my_coobook','1.2.3','http://chef_server')
+        subject.uploaded('my_coobook','1.2.3','http://chef_server')
       }.to raise_error(AbstractFunction)
 
       expect {

data/spec/unit/berkshelf/ui_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Thor::Base.shell do
-  let(:stdout) { double('stdout') }
+  let(:stdout) { double('stdout', tty?: true) }
   let(:stderr) { double('stderr') }
 
   before do
@@ -30,7 +30,7 @@ describe Thor::Base.shell do
       end
 
       it 'does not output anything', :not_supported_on_windows do
-        stdout.should_not_receive(:puts)
+        stdout.should_not_receive(:print)
         subject.say 'message'
       end
     end
@@ -41,7 +41,7 @@ describe Thor::Base.shell do
       end
 
       it 'prints to stdout' do
-        stdout.should_receive(:puts).with('message').once
+        stdout.should_receive(:print).once
         stdout.should_receive(:flush).with(no_args())
         subject.say 'message'
       end
@@ -66,7 +66,7 @@ describe Thor::Base.shell do
       end
 
       it 'prints to stdout' do
-        stdout.should_receive(:puts).with(windows? ? "           5  message" : "\e[1m\e[32m           5\e[0m  message")
+        stdout.should_receive(:print).once
         stdout.should_receive(:flush).with(no_args())
         subject.say_status 5, 'message'
       end
@@ -80,7 +80,7 @@ describe Thor::Base.shell do
       end
 
       it 'does not output anything' do
-        stdout.should_not_receive(:puts)
+        stdout.should_not_receive(:print)
         subject.warn 'warning'
       end
     end
@@ -91,8 +91,7 @@ describe Thor::Base.shell do
       end
 
       it 'calls #say with yellow coloring' do
-        stdout.stub :tty?
-        stdout.should_receive(:puts).with("warning")
+        stdout.should_receive(:print)
         stdout.should_receive(:flush).with(no_args())
         subject.warn 'warning'
       end

data/spec/unit/berkshelf/uploader_spec.rb

@@ -0,0 +1,190 @@
+require 'spec_helper'
+
+module Berkshelf
+  describe Uploader do
+    let(:berksfile) do
+      double(Berksfile,
+        lockfile: lockfile,
+        dependencies: [],
+      )
+    end
+
+    let(:lockfile) do
+      double(Lockfile,
+        graph: graph
+      )
+    end
+
+    let(:graph) { double(Lockfile::Graph, locks: {}) }
+
+    subject { Uploader.new(berksfile) }
+
+    describe '#initialize' do
+      it 'saves the berksfile' do
+        instance = Uploader.new(berksfile)
+        expect(instance.berksfile).to be(berksfile)
+      end
+
+      it 'saves the lockfile' do
+        instance = Uploader.new(berksfile)
+        expect(instance.lockfile).to be(lockfile)
+      end
+
+      it 'saves the options' do
+        instance = Uploader.new(berksfile, force: true, validate: false)
+        options = instance.options
+        expect(options[:force]).to be_true
+        expect(options[:validate]).to be_false
+      end
+
+      it 'saves the names' do
+        instance = Uploader.new(berksfile, 'cookbook_1', 'cookbook_2')
+        expect(instance.names).to eq(['cookbook_1', 'cookbook_2'])
+      end
+    end
+
+    describe '#validate_files!' do
+      before { Uploader.send(:public, :validate_files!) }
+
+      let(:cookbook) { double('cookbook', cookbook_name: 'cookbook', path: 'path') }
+
+      it 'raises an error when the cookbook has spaces in the files' do
+        Dir.stub(:glob).and_return(['/there are/spaces/in this/recipes/default.rb'])
+        expect {
+          subject.validate_files!(cookbook)
+        }.to raise_error
+      end
+
+      it 'does not raise an error when the cookbook is valid' do
+        Dir.stub(:glob).and_return(['/there-are/no-spaces/in-this/recipes/default.rb'])
+        expect {
+          subject.validate_files!(cookbook)
+        }.to_not raise_error
+      end
+
+      it 'does not raise an exception with spaces in the path' do
+        Dir.stub(:glob).and_return(['/there are/spaces/in this/recipes/default.rb'])
+        Pathname.any_instance.stub(:dirname).and_return('/there are/spaces/in this')
+
+        expect {
+          subject.validate_files!(cookbook)
+        }.to_not raise_error
+      end
+    end
+
+    describe '#run' do
+      let(:options) { Hash.new }
+
+      let(:chef_config) do
+        double(Ridley::Chef::Config,
+          node_name: 'fake-client',
+          client_key: 'client-key',
+          chef_server_url: 'http://configured-chef-server/',
+          validation_client_name: 'validator',
+          validation_key: 'validator.pem',
+          cookbook_copyright: 'user',
+          cookbook_email: 'user@example.com',
+          cookbook_license: 'apachev2',
+        )
+      end
+
+      let(:berkshelf_config) do
+        double(Config,
+          ssl:  double(verify: true),
+          chef: chef_config,
+        )
+      end
+
+      let(:default_ridley_options) do
+        {
+          client_name: 'fake-client',
+          client_key: 'client-key',
+          ssl: {
+            verify: true
+          }
+        }
+      end
+
+      before do
+        Berkshelf.stub(:config).and_return(berkshelf_config)
+      end
+
+      context 'when there is no value for :chef_server_url' do
+        before { chef_config.stub(chef_server_url: nil) }
+        let(:message) { 'Missing required attribute in your Berkshelf configuration: chef.server_url' }
+
+        it 'raises an error' do
+          expect { subject.run }.to raise_error(Berkshelf::ChefConnectionError, message)
+        end
+      end
+
+      context 'when there is no value for :client_name' do
+        before { chef_config.stub(node_name: nil) }
+        let(:message) { 'Missing required attribute in your Berkshelf configuration: chef.node_name' }
+
+        it 'raises an error' do
+          expect { subject.run }.to raise_error(Berkshelf::ChefConnectionError, message)
+        end
+      end
+
+      context 'when there is no value for :client_key' do
+        before { chef_config.stub(client_key: nil) }
+        let(:message) { 'Missing required attribute in your Berkshelf configuration: chef.client_key' }
+
+        it 'raises an error' do
+          expect {
+            subject.run
+          }.to raise_error(Berkshelf::ChefConnectionError, message)
+        end
+      end
+
+      context 'when no options are given' do
+        let(:ridley_options) do
+          { server_url: 'http://configured-chef-server/' }.merge(default_ridley_options)
+        end
+
+        it 'uses the Berkshelf::Config options' do
+          expect(Ridley).to receive(:open).with(
+            server_url:  chef_config.chef_server_url,
+            client_name: chef_config.node_name,
+            client_key:  chef_config.client_key,
+            ssl: {
+              verify: berkshelf_config.ssl.verify
+            }
+          )
+          subject.run
+        end
+      end
+
+      context 'when a Chef Server url is passed as an option' do
+        subject { Uploader.new(berksfile, server_url: 'http://custom') }
+
+        it 'uses the passed in :server_url' do
+          expect(Ridley).to receive(:open)
+            .with(include(server_url: 'http://custom'))
+          subject.run
+        end
+      end
+
+      context 'when a client name is passed as an option' do
+        subject { Uploader.new(berksfile, client_name: 'custom') }
+
+        it 'uses the passed in :client_name' do
+          expect(Ridley).to receive(:open)
+            .with(include(client_name: 'custom'))
+          subject.run
+        end
+      end
+
+      context 'when a client key is passed as an option' do
+        subject { Uploader.new(berksfile, client_key: 'custom') }
+
+        it 'uses the passed in :client_key' do
+          expect(Ridley).to receive(:open)
+            .with(include(client_key: 'custom'))
+          subject.run
+        end
+      end
+    end
+  end
+end