chef 12.4.0.rc.0-universal-mingw32

data/spec/unit/knife/cookbook_download_spec.rb

@@ -0,0 +1,238 @@
+#
+# Author:: Thomas Bishop (<bishop.thomas@gmail.com>)
+# Copyright:: Copyright (c) 2011 Thomas Bishop
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+describe Chef::Knife::CookbookDownload do
+  before(:each) do
+    @knife = Chef::Knife::CookbookDownload.new
+    @stderr = StringIO.new
+    allow(@knife.ui).to receive(:stderr).and_return(@stderr)
+  end
+
+  describe 'run' do
+    it 'should print usage and exit when a cookbook name is not provided' do
+      @knife.name_args = []
+      expect(@knife).to receive(:show_usage)
+      expect(@knife.ui).to receive(:fatal).with(/must specify a cookbook name/)
+      expect { @knife.run }.to raise_error(SystemExit)
+    end
+
+    it 'should exit with a fatal error when there is no cookbook on the server' do
+      @knife.name_args = ['foobar', nil]
+      expect(@knife).to receive(:determine_version).and_return(nil)
+      expect(@knife.ui).to receive(:fatal).with('No such cookbook found')
+      expect { @knife.run }.to raise_error(SystemExit)
+    end
+
+    describe 'with a cookbook name' do
+      before(:each) do
+        @knife.name_args = ['foobar']
+        @knife.config[:download_directory] = '/var/tmp/chef'
+        @rest_mock = double('rest')
+        allow(@knife).to receive(:rest).and_return(@rest_mock)
+
+        @manifest_data = {
+          :recipes => [
+            {'path' => 'recipes/foo.rb',
+             'url' => 'http://example.org/files/foo.rb'},
+            {'path' => 'recipes/bar.rb',
+             'url' => 'http://example.org/files/bar.rb'}
+          ],
+          :templates => [
+            {'path' => 'templates/default/foo.erb',
+             'url' => 'http://example.org/files/foo.erb'},
+            {'path' => 'templates/default/bar.erb',
+             'url' => 'http://example.org/files/bar.erb'}
+          ],
+          :attributes => [
+            {'path' => 'attributes/default.rb',
+             'url' => 'http://example.org/files/default.rb'}
+          ]
+        }
+
+        @cookbook_mock = double('cookbook')
+        allow(@cookbook_mock).to receive(:version).and_return('1.0.0')
+        allow(@cookbook_mock).to receive(:manifest).and_return(@manifest_data)
+        expect(@rest_mock).to receive(:get_rest).with('cookbooks/foobar/1.0.0').
+                                             and_return(@cookbook_mock)
+      end
+
+      it 'should determine which version if one was not explicitly specified'do
+        allow(@cookbook_mock).to receive(:manifest).and_return({})
+        expect(@knife).to receive(:determine_version).and_return('1.0.0')
+        expect(File).to receive(:exists?).with('/var/tmp/chef/foobar-1.0.0').and_return(false)
+        allow(Chef::CookbookVersion).to receive(:COOKBOOK_SEGEMENTS).and_return([])
+        @knife.run
+      end
+
+      describe 'and a version' do
+        before(:each) do
+          @knife.name_args << '1.0.0'
+          @files = @manifest_data.values.map { |v| v.map { |i| i['path'] } }.flatten.uniq
+          @files_mocks = {}
+          @files.map { |f| File.basename(f) }.flatten.uniq.each do |f|
+            @files_mocks[f] = double("#{f}_mock")
+            allow(@files_mocks[f]).to receive(:path).and_return("/var/tmp/#{f}")
+          end
+        end
+
+        it 'should print an error and exit if the cookbook download directory already exists' do
+          expect(File).to receive(:exists?).with('/var/tmp/chef/foobar-1.0.0').and_return(true)
+          expect(@knife.ui).to receive(:fatal).with(/\/var\/tmp\/chef\/foobar-1\.0\.0 exists/i)
+          expect { @knife.run }.to raise_error(SystemExit)
+        end
+
+        describe 'when downloading the cookbook' do
+          before(:each) do
+            @files.map { |f| File.dirname(f) }.flatten.uniq.each do |dir|
+              expect(FileUtils).to receive(:mkdir_p).with("/var/tmp/chef/foobar-1.0.0/#{dir}").
+              at_least(:once)
+            end
+
+            @files_mocks.each_pair do |file, mock|
+              expect(@rest_mock).to receive(:get_rest).with("http://example.org/files/#{file}", true).
+              and_return(mock)
+            end
+
+            expect(@rest_mock).to receive(:sign_on_redirect=).with(false).at_least(:once)
+            @files.each do |f|
+              expect(FileUtils).to receive(:mv).
+                        with("/var/tmp/#{File.basename(f)}", "/var/tmp/chef/foobar-1.0.0/#{f}")
+            end
+          end
+
+          it "should download the cookbook when the cookbook download directory doesn't exist" do
+            expect(File).to receive(:exists?).with('/var/tmp/chef/foobar-1.0.0').and_return(false)
+            @knife.run
+            ['attributes', 'recipes', 'templates'].each do |segment|
+              expect(@stderr.string).to match /downloading #{segment}/im
+            end
+            expect(@stderr.string).to match /downloading foobar cookbook version 1\.0\.0/im
+            expect(@stderr.string).to match /cookbook downloaded to \/var\/tmp\/chef\/foobar-1\.0\.0/im
+          end
+
+          describe 'with -f or --force' do
+            it 'should remove the existing the cookbook download directory if it exists' do
+              @knife.config[:force] = true
+              expect(File).to receive(:exists?).with('/var/tmp/chef/foobar-1.0.0').and_return(true)
+              expect(FileUtils).to receive(:rm_rf).with('/var/tmp/chef/foobar-1.0.0')
+              @knife.run
+            end
+          end
+        end
+
+      end
+    end
+
+  end
+
+  describe 'determine_version' do
+
+    it 'should return nil if there are no versions' do
+      expect(@knife).to receive(:available_versions).and_return(nil)
+      expect(@knife.determine_version).to eq(nil)
+      expect(@knife.version).to eq(nil)
+    end
+
+    it 'should return and set the version if there is only one version' do
+      expect(@knife).to receive(:available_versions).at_least(:once).and_return(['1.0.0'])
+      expect(@knife.determine_version).to eq('1.0.0')
+      expect(@knife.version).to eq('1.0.0')
+    end
+
+    it 'should ask which version to download and return it if there is more than one' do
+      expect(@knife).to receive(:available_versions).at_least(:once).and_return(['1.0.0', '2.0.0'])
+      expect(@knife).to receive(:ask_which_version).and_return('1.0.0')
+      expect(@knife.determine_version).to eq('1.0.0')
+    end
+
+    describe 'with -N or --latest' do
+      it 'should return and set the version to the latest version' do
+        @knife.config[:latest] = true
+        expect(@knife).to receive(:available_versions).at_least(:once).
+                                                   and_return(['1.0.0', '1.1.0', '2.0.0'])
+        @knife.determine_version
+        expect(@knife.version.to_s).to eq('2.0.0')
+      end
+    end
+  end
+
+  describe 'available_versions' do
+    before(:each) do
+      @knife.cookbook_name = 'foobar'
+    end
+
+    it 'should return nil if there are no versions' do
+      expect(Chef::CookbookVersion).to receive(:available_versions).
+                            with('foobar').
+                            and_return(nil)
+      expect(@knife.available_versions).to eq(nil)
+    end
+
+    it 'should return the available versions' do
+      expect(Chef::CookbookVersion).to receive(:available_versions).
+                            with('foobar').
+                            and_return(['1.1.0', '2.0.0', '1.0.0'])
+      expect(@knife.available_versions).to eq([Chef::Version.new('1.0.0'),
+                                           Chef::Version.new('1.1.0'),
+                                           Chef::Version.new('2.0.0')])
+    end
+
+    it 'should avoid multiple API calls to the server' do
+      expect(Chef::CookbookVersion).to receive(:available_versions).
+                            once.
+                            with('foobar').
+                            and_return(['1.1.0', '2.0.0', '1.0.0'])
+      @knife.available_versions
+      @knife.available_versions
+    end
+  end
+
+  describe 'ask_which_version' do
+    before(:each) do
+      @knife.cookbook_name = 'foobar'
+      allow(@knife).to receive(:available_versions).and_return(['1.0.0', '1.1.0', '2.0.0'])
+    end
+
+    it 'should prompt the user to select a version' do
+      prompt = /Which version do you want to download\?.+1\. foobar 1\.0\.0.+2\. foobar 1\.1\.0.+3\. foobar 2\.0\.0.+/m
+      expect(@knife).to receive(:ask_question).with(prompt).and_return('1')
+      @knife.ask_which_version
+    end
+
+    it "should set the version to the user's selection" do
+      expect(@knife).to receive(:ask_question).and_return('1')
+      @knife.ask_which_version
+      expect(@knife.version).to eq('1.0.0')
+    end
+
+    it "should print an error and exit if a version wasn't specified" do
+      expect(@knife).to receive(:ask_question).and_return('')
+      expect(@knife.ui).to receive(:error).with(/is not a valid value/i)
+      expect { @knife.ask_which_version }.to raise_error(SystemExit)
+    end
+
+    it 'should print an error if an invalid choice was selected' do
+      expect(@knife).to receive(:ask_question).and_return('100')
+      expect(@knife.ui).to receive(:error).with(/'100' is not a valid value/i)
+      expect { @knife.ask_which_version }.to raise_error(SystemExit)
+    end
+  end
+
+end

data/spec/unit/knife/cookbook_list_spec.rb

@@ -0,0 +1,88 @@
+#
+# Author:: Thomas Bishop (<bishop.thomas@gmail.com>)
+# Copyright:: Copyright (c) 2011 Thomas Bishop
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+describe Chef::Knife::CookbookList do
+  before do
+    @knife = Chef::Knife::CookbookList.new
+    @rest_mock = double('rest')
+    allow(@knife).to receive(:rest).and_return(@rest_mock)
+    @cookbook_names = ['apache2', 'mysql']
+    @base_url = 'https://server.example.com/cookbooks'
+    @cookbook_data = {}
+    @cookbook_names.each do |item|
+      @cookbook_data[item] = {'url' => "#{@base_url}/#{item}",
+                              'versions' => [{'version' => '1.0.1',
+                                              'url' => "#{@base_url}/#{item}/1.0.1"}]}
+    end
+    @stdout = StringIO.new
+    allow(@knife.ui).to receive(:stdout).and_return(@stdout)
+  end
+
+  describe 'run' do
+    it 'should display the latest version of the cookbooks' do
+      expect(@rest_mock).to receive(:get_rest).with('/cookbooks?num_versions=1').
+                                           and_return(@cookbook_data)
+      @knife.run
+      @cookbook_names.each do |item|
+        expect(@stdout.string).to match /#{item}\s+1\.0\.1/
+      end
+    end
+
+    it 'should query cookbooks for the configured environment' do
+      @knife.config[:environment] = 'production'
+      expect(@rest_mock).to receive(:get_rest).
+                 with('/environments/production/cookbooks?num_versions=1').
+                 and_return(@cookbook_data)
+      @knife.run
+    end
+
+    describe 'with -w or --with-uri' do
+      it 'should display the cookbook uris' do
+        @knife.config[:with_uri] = true
+        allow(@rest_mock).to receive(:get_rest).and_return(@cookbook_data)
+        @knife.run
+        @cookbook_names.each do |item|
+          pattern = /#{Regexp.escape(@cookbook_data[item]['versions'].first['url'])}/
+          expect(@stdout.string).to match pattern
+        end
+      end
+    end
+
+    describe 'with -a or --all' do
+      before do
+        @cookbook_names.each do |item|
+          @cookbook_data[item]['versions'] << {'version' => '1.0.0',
+                                               'url' => "#{@base_url}/#{item}/1.0.0"}
+        end
+      end
+
+      it 'should display all versions of the cookbooks' do
+        @knife.config[:all_versions] = true
+        expect(@rest_mock).to receive(:get_rest).with('/cookbooks?num_versions=all').
+                                             and_return(@cookbook_data)
+        @knife.run
+        @cookbook_names.each do |item|
+          expect(@stdout.string).to match /#{item}\s+1\.0\.1\s+1\.0\.0/
+        end
+      end
+    end
+
+  end
+end

data/spec/unit/knife/cookbook_metadata_from_file_spec.rb

@@ -0,0 +1,65 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Matthew Kent (<mkent@magoazul.com>)
+# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# Copyright:: Copyright (c) 2010 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+describe Chef::Knife::CookbookMetadataFromFile do
+  before(:each) do
+    Chef::Config[:node_name]  = "webmonkey.example.com"
+    @src = File.expand_path(File.join(CHEF_SPEC_DATA, "metadata", "quick_start", "metadata.rb"))
+    @tgt = File.expand_path(File.join(CHEF_SPEC_DATA, "metadata", "quick_start", "metadata.json"))
+    @knife = Chef::Knife::CookbookMetadataFromFile.new
+    @knife.name_args = [ @src ]
+    allow(@knife).to receive(:to_json_pretty).and_return(true)
+    @md = Chef::Cookbook::Metadata.new
+    allow(Chef::Cookbook::Metadata).to receive(:new).and_return(@md)
+    allow($stdout).to receive(:write)
+  end
+
+  after do
+    if File.exists?(@tgt)
+      File.unlink(@tgt)
+    end
+  end
+
+  describe "run" do
+    it "should determine cookbook name from path" do
+      expect(@md).to receive(:name).with(no_args)
+      expect(@md).to receive(:name).with("quick_start")
+      @knife.run
+    end
+
+    it "should load the metadata source" do
+      expect(@md).to receive(:from_file).with(@src)
+      @knife.run
+    end
+
+    it "should write out the metadata to the correct location" do
+      expect(File).to receive(:open).with(@tgt, "w")
+      @knife.run
+    end
+
+    it "should generate json from the metadata" do
+      expect(Chef::JSONCompat).to receive(:to_json_pretty).with(@md)
+      @knife.run
+    end
+
+  end
+end

data/spec/unit/knife/cookbook_metadata_spec.rb

@@ -0,0 +1,179 @@
+#
+# Author:: Thomas Bishop (<bishop.thomas@gmail.com>)
+# Copyright:: Copyright (c) 2011 Thomas Bishop
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+describe Chef::Knife::CookbookMetadata do
+  before(:each) do
+    @knife = Chef::Knife::CookbookMetadata.new
+    @knife.name_args = ['foobar']
+    @cookbook_dir = Dir.mktmpdir
+    @json_data = '{ "version": "1.0.0" }'
+    @stdout = StringIO.new
+    @stderr = StringIO.new
+    allow(@knife.ui).to receive(:stdout).and_return(@stdout)
+    allow(@knife.ui).to receive(:stderr).and_return(@stderr)
+  end
+
+  describe 'run' do
+    it 'should print an error and exit if a cookbook name was not provided' do
+      @knife.name_args = []
+      expect(@knife.ui).to receive(:error).with(/you must specify the cookbook.+use the --all/i)
+      expect { @knife.run }.to raise_error(SystemExit)
+    end
+
+    it 'should print an error and exit if an empty cookbook name was provided' do
+      @knife.name_args = ['']
+      expect(@knife.ui).to receive(:error).with(/you must specify the cookbook.+use the --all/i)
+      expect { @knife.run }.to raise_error(SystemExit)
+    end
+
+    it 'should generate the metadata for the cookbook' do
+      expect(@knife).to receive(:generate_metadata).with('foobar')
+      @knife.run
+    end
+
+    describe 'with -a or --all' do
+      before(:each) do
+        @knife.config[:all] = true
+        @foo = Chef::CookbookVersion.new('foo', '/tmp/blah')
+        @foo.version = '1.0.0'
+        @bar = Chef::CookbookVersion.new('bar', '/tmp/blah')
+        @bar.version = '2.0.0'
+        @cookbook_loader = {
+          "foo" => @foo,
+          "bar" => @bar
+        }
+        expect(@cookbook_loader).to receive(:load_cookbooks).and_return(@cookbook_loader)
+        expect(@knife).to receive(:generate_metadata).with('foo')
+        expect(@knife).to receive(:generate_metadata).with('bar')
+      end
+
+      it 'should generate the metadata for each cookbook' do
+        Chef::Config[:cookbook_path] = @cookbook_dir
+        expect(Chef::CookbookLoader).to receive(:new).with(@cookbook_dir).and_return(@cookbook_loader)
+        @knife.run
+      end
+
+      describe 'and with -o or --cookbook-path' do
+        it 'should look in the provided path and generate cookbook metadata' do
+          @knife.config[:cookbook_path] = '/opt/chef/cookbooks'
+          expect(Chef::CookbookLoader).to receive(:new).with('/opt/chef/cookbooks').and_return(@cookbook_loader)
+          @knife.run
+        end
+      end
+    end
+
+  end
+
+  describe 'generate_metadata' do
+    before(:each) do
+      @knife.config[:cookbook_path] = @cookbook_dir
+      allow(File).to receive(:expand_path).with("#{@cookbook_dir}/foobar/metadata.rb").
+                                    and_return("#{@cookbook_dir}/foobar/metadata.rb")
+    end
+
+    it 'should generate the metadata from metadata.rb if it exists' do
+      expect(File).to receive(:exists?).with("#{@cookbook_dir}/foobar/metadata.rb").
+                                    and_return(true)
+      expect(@knife).to receive(:generate_metadata_from_file).with('foobar', "#{@cookbook_dir}/foobar/metadata.rb")
+      @knife.run
+    end
+
+    it 'should validate the metadata json if metadata.rb does not exist' do
+      expect(File).to receive(:exists?).with("#{@cookbook_dir}/foobar/metadata.rb").
+                                    and_return(false)
+      expect(@knife).to receive(:validate_metadata_json).with(@cookbook_dir, 'foobar')
+      @knife.run
+    end
+  end
+
+  describe 'generate_metadata_from_file' do
+    before(:each) do
+      @metadata_mock = double('metadata')
+      @json_file_mock = double('json_file')
+    end
+
+    it 'should generate the metatdata json from metatdata.rb' do
+      allow(Chef::Cookbook::Metadata).to receive(:new).and_return(@metadata_mock)
+      expect(@metadata_mock).to receive(:name).with('foobar')
+      expect(@metadata_mock).to receive(:from_file).with("#{@cookbook_dir}/foobar/metadata.rb")
+      expect(File).to receive(:open).with("#{@cookbook_dir}/foobar/metadata.json", 'w').
+                                 and_yield(@json_file_mock)
+      expect(@json_file_mock).to receive(:write).with(@json_data)
+      expect(Chef::JSONCompat).to receive(:to_json_pretty).with(@metadata_mock).
+                                                       and_return(@json_data)
+      @knife.generate_metadata_from_file('foobar', "#{@cookbook_dir}/foobar/metadata.rb")
+      expect(@stderr.string).to match /generating metadata for foobar from #{@cookbook_dir}\/foobar\/metadata\.rb/im
+    end
+
+    { Chef::Exceptions::ObsoleteDependencySyntax => 'obsolote dependency',
+      Chef::Exceptions::InvalidVersionConstraint => 'invalid version constraint'
+    }.each_pair do |klass, description|
+      it "should print an error and exit when an #{description} syntax exception is encountered" do
+        exception = klass.new("#{description} blah")
+        allow(Chef::Cookbook::Metadata).to receive(:new).and_raise(exception)
+        expect {
+          @knife.generate_metadata_from_file('foobar', "#{@cookbook_dir}/foobar/metadata.rb")
+        }.to raise_error(SystemExit)
+        expect(@stderr.string).to match /error: the cookbook 'foobar' contains invalid or obsolete metadata syntax/im
+        expect(@stderr.string).to match /in #{@cookbook_dir}\/foobar\/metadata\.rb/im
+        expect(@stderr.string).to match /#{description} blah/im
+      end
+    end
+  end
+
+  describe 'validate_metadata_json' do
+    it 'should validate the metadata json' do
+      expect(File).to receive(:exist?).with("#{@cookbook_dir}/foobar/metadata.json").
+                                   and_return(true)
+      expect(IO).to receive(:read).with("#{@cookbook_dir}/foobar/metadata.json").
+                               and_return(@json_data)
+      expect(Chef::Cookbook::Metadata).to receive(:validate_json).with(@json_data)
+      @knife.validate_metadata_json(@cookbook_dir, 'foobar')
+    end
+
+    it 'should not try to validate the metadata json if the file does not exist' do
+      expect(File).to receive(:exist?).with("#{@cookbook_dir}/foobar/metadata.json").
+                                   and_return(false)
+      expect(IO).not_to receive(:read)
+      expect(Chef::Cookbook::Metadata).not_to receive(:validate_json)
+      @knife.validate_metadata_json(@cookbook_dir, 'foobar')
+    end
+
+    { Chef::Exceptions::ObsoleteDependencySyntax => 'obsolote dependency',
+      Chef::Exceptions::InvalidVersionConstraint => 'invalid version constraint'
+    }.each_pair do |klass, description|
+      it "should print an error and exit when an #{description} syntax exception is encountered" do
+        expect(File).to receive(:exist?).with("#{@cookbook_dir}/foobar/metadata.json").
+                                     and_return(true)
+        expect(IO).to receive(:read).with("#{@cookbook_dir}/foobar/metadata.json").
+                                 and_return(@json_data)
+        exception = klass.new("#{description} blah")
+        allow(Chef::Cookbook::Metadata).to receive(:validate_json).and_raise(exception)
+        expect {
+          @knife.validate_metadata_json(@cookbook_dir, 'foobar')
+        }.to raise_error(SystemExit)
+        expect(@stderr.string).to match /error: the cookbook 'foobar' contains invalid or obsolete metadata syntax/im
+        expect(@stderr.string).to match /in #{@cookbook_dir}\/foobar\/metadata\.json/im
+        expect(@stderr.string).to match /#{description} blah/im
+      end
+    end
+  end
+
+end