chef 12.4.0.rc.0-universal-mingw32

data/spec/unit/knife/cookbook_show_spec.rb

@@ -0,0 +1,223 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# License:: Apache License, eersion 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.
+#
+
+# rename to cookbook not coookbook
+require 'spec_helper'
+
+describe Chef::Knife::CookbookShow do
+  before(:each) do
+    Chef::Config[:node_name]  = "webmonkey.example.com"
+    @knife = Chef::Knife::CookbookShow.new
+    @knife.config = { }
+    @knife.name_args = [ "cookbook_name" ]
+    @rest = double(Chef::REST)
+    allow(@knife).to receive(:rest).and_return(@rest)
+    allow(@knife).to receive(:pretty_print).and_return(true)
+    allow(@knife).to receive(:output).and_return(true)
+  end
+
+  describe "run" do
+    describe "with 0 arguments: help" do
+      it 'should should print usage and exit when given no arguments' do
+        @knife.name_args = []
+        expect(@knife).to receive(:show_usage)
+        expect(@knife.ui).to receive(:fatal)
+        expect { @knife.run }.to raise_error(SystemExit)
+      end
+    end
+
+    describe "with 1 argument: versions" do
+      before(:each) do
+        @response = {
+          "cookbook_name" => {
+            "url" => "http://url/cookbooks/cookbook_name",
+            "versions" => [
+              { "version" => "0.10.0", "url" => "http://url/cookbooks/cookbook_name/0.10.0" },
+              { "version" => "0.9.0", "url" => "http://url/cookbookx/cookbook_name/0.9.0" },
+              { "version" => "0.8.0", "url" => "http://url/cookbooks/cookbook_name/0.8.0" }
+            ]
+          }
+        }
+      end
+
+      it "should show the raw cookbook data" do
+        expect(@rest).to receive(:get_rest).with("cookbooks/cookbook_name").and_return(@response)
+        expect(@knife).to receive(:format_cookbook_list_for_display).with(@response)
+        @knife.run
+      end
+
+      it "should respect the user-supplied environment" do
+        @knife.config[:environment] = "foo"
+        expect(@rest).to receive(:get_rest).with("environments/foo/cookbooks/cookbook_name").and_return(@response)
+        expect(@knife).to receive(:format_cookbook_list_for_display).with(@response)
+        @knife.run
+      end
+    end
+
+    describe "with 2 arguments: name and version" do
+      before(:each) do
+        @knife.name_args << "0.1.0"
+        @response = { "0.1.0" => { "recipes" => {"default.rb" => ""} } }
+      end
+
+      it "should show the specific part of a cookbook" do
+        expect(@rest).to receive(:get_rest).with("cookbooks/cookbook_name/0.1.0").and_return(@response)
+        expect(@knife).to receive(:output).with(@response)
+        @knife.run
+      end
+    end
+
+    describe "with 3 arguments: name, version, and segment" do
+      before(:each) do
+        @knife.name_args = [ "cookbook_name", "0.1.0", "recipes" ]
+        @cookbook_response = Chef::CookbookVersion.new("cookbook_name")
+        @manifest = {
+          "recipes" => [
+            {
+              :name => "default.rb",
+              :path => "recipes/default.rb",
+              :checksum => "1234",
+              :url => "http://example.org/files/default.rb"
+            }
+          ]
+        }
+        @cookbook_response.manifest = @manifest
+        @response = {"name"=>"default.rb", "url"=>"http://example.org/files/default.rb", "checksum"=>"1234", "path"=>"recipes/default.rb"}
+      end
+
+      it "should print the json of the part" do
+        expect(@rest).to receive(:get_rest).with("cookbooks/cookbook_name/0.1.0").and_return(@cookbook_response)
+        expect(@knife).to receive(:output).with(@cookbook_response.manifest["recipes"])
+        @knife.run
+      end
+    end
+
+    describe "with 4 arguments: name, version, segment and filename" do
+      before(:each) do
+        @knife.name_args = [ "cookbook_name", "0.1.0", "recipes", "default.rb" ]
+        @cookbook_response = Chef::CookbookVersion.new("cookbook_name")
+        @cookbook_response.manifest = {
+          "recipes" => [
+            {
+              :name => "default.rb",
+              :path => "recipes/default.rb",
+              :checksum => "1234",
+              :url => "http://example.org/files/default.rb"
+            }
+          ]
+        }
+        @response = "Example recipe text"
+      end
+
+      it "should print the raw result of the request (likely a file!)" do
+        expect(@rest).to receive(:get_rest).with("cookbooks/cookbook_name/0.1.0").and_return(@cookbook_response)
+        expect(@rest).to receive(:get_rest).with("http://example.org/files/default.rb", true).and_return(StringIO.new(@response))
+        expect(@knife).to receive(:pretty_print).with(@response)
+        @knife.run
+      end
+    end
+
+    describe "with 4 arguments: name, version, segment and filename -- with specificity" do
+      before(:each) do
+        @knife.name_args = [ "cookbook_name", "0.1.0", "files", "afile.rb" ]
+        @cookbook_response = Chef::CookbookVersion.new("cookbook_name")
+        @cookbook_response.manifest = {
+          "files" => [
+            {
+              :name => "afile.rb",
+              :path => "files/host-examplehost.example.org/afile.rb",
+              :checksum => "1111",
+              :specificity => "host-examplehost.example.org",
+              :url => "http://example.org/files/1111"
+            },
+            {
+              :name => "afile.rb",
+              :path => "files/ubuntu-9.10/afile.rb",
+              :checksum => "2222",
+              :specificity => "ubuntu-9.10",
+              :url => "http://example.org/files/2222"
+            },
+            {
+              :name => "afile.rb",
+              :path => "files/ubuntu/afile.rb",
+              :checksum => "3333",
+              :specificity => "ubuntu",
+              :url => "http://example.org/files/3333"
+            },
+            {
+              :name => "afile.rb",
+              :path => "files/default/afile.rb",
+              :checksum => "4444",
+              :specificity => "default",
+              :url => "http://example.org/files/4444"
+            },
+          ]
+        }
+
+        @response = "Example recipe text"
+      end
+
+      describe "with --fqdn" do
+        it "should pass the fqdn" do
+          @knife.config[:platform] = "example_platform"
+          @knife.config[:platform_version] = "1.0"
+          @knife.config[:fqdn] = "examplehost.example.org"
+          expect(@rest).to receive(:get_rest).with("cookbooks/cookbook_name/0.1.0").and_return(@cookbook_response)
+          expect(@rest).to receive(:get_rest).with("http://example.org/files/1111", true).and_return(StringIO.new(@response))
+          expect(@knife).to receive(:pretty_print).with(@response)
+          @knife.run
+        end
+      end
+
+      describe "and --platform" do
+        it "should pass the platform" do
+          @knife.config[:platform] = "ubuntu"
+          @knife.config[:platform_version] = "1.0"
+          @knife.config[:fqdn] = "differenthost.example.org"
+          expect(@rest).to receive(:get_rest).with("cookbooks/cookbook_name/0.1.0").and_return(@cookbook_response)
+          expect(@rest).to receive(:get_rest).with("http://example.org/files/3333", true).and_return(StringIO.new(@response))
+          expect(@knife).to receive(:pretty_print).with(@response)
+          @knife.run
+        end
+      end
+
+      describe "and --platform-version" do
+        it "should pass the platform" do
+          @knife.config[:platform] = "ubuntu"
+          @knife.config[:platform_version] = "9.10"
+          @knife.config[:fqdn] = "differenthost.example.org"
+          expect(@rest).to receive(:get_rest).with("cookbooks/cookbook_name/0.1.0").and_return(@cookbook_response)
+          expect(@rest).to receive(:get_rest).with("http://example.org/files/2222", true).and_return(StringIO.new(@response))
+          expect(@knife).to receive(:pretty_print).with(@response)
+          @knife.run
+        end
+      end
+
+      describe "with none of the arguments, it should use the default" do
+        it "should pass them all" do
+          expect(@rest).to receive(:get_rest).with("cookbooks/cookbook_name/0.1.0").and_return(@cookbook_response)
+          expect(@rest).to receive(:get_rest).with("http://example.org/files/4444", true).and_return(StringIO.new(@response))
+          expect(@knife).to receive(:pretty_print).with(@response)
+          @knife.run
+        end
+      end
+
+    end
+  end
+end
+

data/spec/unit/knife/cookbook_site_download_spec.rb

@@ -0,0 +1,151 @@
+#
+# Author:: Thomas Bishop (<bishop.thomas@gmail.com>)
+# Copyright:: Copyright (c) 2012 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 File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe Chef::Knife::CookbookSiteDownload do
+
+  describe 'run' do
+    before do
+      @knife            = Chef::Knife::CookbookSiteDownload.new
+      @knife.name_args  = ['apache2']
+      @noauth_rest      = double('no auth rest')
+      @stderr           = StringIO.new
+      @cookbook_api_url = 'https://supermarket.chef.io/api/v1/cookbooks'
+      @version          = '1.0.2'
+      @version_us       = @version.gsub '.', '_'
+      @current_data     = { 'deprecated'       => false,
+                            'latest_version'   => "#{@cookbook_api_url}/apache2/versions/#{@version_us}",
+                            'replacement' => 'other_apache2' }
+
+      allow(@knife.ui).to receive(:stderr).and_return(@stderr)
+      allow(@knife).to receive(:noauth_rest).and_return(@noauth_rest)
+      expect(@noauth_rest).to receive(:get_rest).
+                   with("#{@cookbook_api_url}/apache2").
+                   and_return(@current_data)
+    end
+
+    context 'when the cookbook is deprecated and not forced' do
+      before do
+        @current_data['deprecated'] = true
+      end
+
+      it 'should warn with info about the replacement' do
+        expect(@knife.ui).to receive(:warn).
+                  with(/.+deprecated.+replaced by other_apache2.+/i)
+        expect(@knife.ui).to receive(:warn).
+                  with(/use --force.+download.+/i)
+        @knife.run
+      end
+    end
+
+    context 'when' do
+      before do
+        @cookbook_data = { 'version' => @version,
+                           'file'    => "http://example.com/apache2_#{@version_us}.tgz" }
+        @temp_file     =  double( :path => "/tmp/apache2_#{@version_us}.tgz" )
+        @file          = File.join(Dir.pwd, "apache2-#{@version}.tar.gz")
+
+        expect(@noauth_rest).to receive(:sign_on_redirect=).with(false)
+      end
+
+      context 'downloading the latest version' do
+        before do
+          expect(@noauth_rest).to receive(:get_rest).
+                       with(@current_data['latest_version']).
+                       and_return(@cookbook_data)
+          expect(@noauth_rest).to receive(:get_rest).
+                       with(@cookbook_data['file'], true).
+                       and_return(@temp_file)
+        end
+
+        context 'and it is deprecated and with --force' do
+          before do
+            @current_data['deprecated'] = true
+            @knife.config[:force] = true
+          end
+
+          it 'should download the latest version' do
+            expect(@knife.ui).to receive(:warn).
+                      with(/.+deprecated.+replaced by other_apache2.+/i)
+            expect(FileUtils).to receive(:cp).with(@temp_file.path, @file)
+            @knife.run
+            expect(@stderr.string).to match /downloading apache2.+version.+#{Regexp.escape(@version)}/i
+            expect(@stderr.string).to match /cookbook save.+#{Regexp.escape(@file)}/i
+          end
+
+        end
+
+        it 'should download the latest version' do
+          expect(FileUtils).to receive(:cp).with(@temp_file.path, @file)
+          @knife.run
+          expect(@stderr.string).to match /downloading apache2.+version.+#{Regexp.escape(@version)}/i
+          expect(@stderr.string).to match /cookbook save.+#{Regexp.escape(@file)}/i
+        end
+
+        context 'with -f or --file' do
+          before do
+            @file = '/opt/chef/cookbooks/apache2.tar.gz'
+            @knife.config[:file] = @file
+            expect(FileUtils).to receive(:cp).with(@temp_file.path, @file)
+          end
+
+          it 'should download the cookbook to the desired file' do
+            @knife.run
+            expect(@stderr.string).to match /downloading apache2.+version.+#{Regexp.escape(@version)}/i
+            expect(@stderr.string).to match /cookbook save.+#{Regexp.escape(@file)}/i
+          end
+        end
+
+        it 'should provide an accessor to the version' do
+          allow(FileUtils).to receive(:cp).and_return(true)
+          expect(@knife.version).to eq(@version)
+          @knife.run
+        end
+      end
+
+      context 'downloading a cookbook of a specific version' do
+        before do
+          @version         = '1.0.1'
+          @version_us      = @version.gsub '.', '_'
+          @cookbook_data   = { 'version' => @version,
+                               'file'    => "http://example.com/apache2_#{@version_us}.tgz" }
+          @temp_file       = double(:path => "/tmp/apache2_#{@version_us}.tgz")
+          @file            = File.join(Dir.pwd, "apache2-#{@version}.tar.gz")
+          @knife.name_args << @version
+        end
+
+        it 'should download the desired version' do
+          expect(@noauth_rest).to receive(:get_rest).
+                       with("#{@cookbook_api_url}/apache2/versions/#{@version_us}").
+                       and_return(@cookbook_data)
+          expect(@noauth_rest).to receive(:get_rest).
+                       with(@cookbook_data['file'], true).
+                       and_return(@temp_file)
+          expect(FileUtils).to receive(:cp).with(@temp_file.path, @file)
+          @knife.run
+          expect(@stderr.string).to match /downloading apache2.+version.+#{Regexp.escape(@version)}/i
+          expect(@stderr.string).to match /cookbook save.+#{Regexp.escape(@file)}/i
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/unit/knife/cookbook_site_install_spec.rb

@@ -0,0 +1,195 @@
+#
+# Author:: Steven Danna (<steve@opscode.com>)
+# Copyright:: Copyright (c) 2011 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 File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "spec_helper"))
+
+describe Chef::Knife::CookbookSiteInstall do
+  let(:knife) { Chef::Knife::CookbookSiteInstall.new }
+  let(:stdout) { StringIO.new }
+  let(:stderr) { StringIO.new }
+  let(:downloader) { Hash.new }
+  let(:repo) { double(:sanity_check => true, :reset_to_default_state => true,
+                      :prepare_to_import => true, :finalize_updates_to => true,
+                      :merge_updates_from => true) }
+  let(:install_path) { if Chef::Platform.windows?
+                        'C:/tmp/chef'
+                      else
+                        '/var/tmp/chef'
+                      end }
+
+  before(:each) do
+    require 'chef/knife/core/cookbook_scm_repo'
+
+    allow(knife.ui).to receive(:stdout).and_return(stdout)
+    knife.config = {}
+    knife.config[:cookbook_path] = [ install_path ]
+
+    allow(knife).to receive(:stderr).and_return(stderr)
+    allow(knife).to receive(:stdout).and_return(stdout)
+
+    # Assume all external commands would have succeed. :(
+    allow(File).to receive(:unlink)
+    allow(File).to receive(:rmtree)
+    allow(knife).to receive(:shell_out!).and_return(true)
+
+    # CookbookSiteDownload Stup
+    allow(knife).to receive(:download_cookbook_to).and_return(downloader)
+    allow(downloader).to receive(:version) do
+      if knife.name_args.size == 2
+        knife.name_args[1]
+      else
+        "0.3.0"
+      end
+    end
+
+    # Stubs for CookbookSCMRepo
+    allow(Chef::Knife::CookbookSCMRepo).to receive(:new).and_return(repo)
+  end
+
+  describe "run" do
+    it "raises an error if a cookbook name is not provided" do
+      knife.name_args = []
+      expect(knife.ui).to receive(:error).with("Please specify a cookbook to download and install.")
+      expect { knife.run }.to raise_error(SystemExit)
+    end
+
+    it "raises an error if more than two arguments are given" do
+      knife.name_args = ["foo", "bar", "baz"]
+      expect(knife.ui).to receive(:error).with("Installing multiple cookbooks at once is not supported.")
+      expect { knife.run }.to raise_error(SystemExit)
+    end
+
+    it "raises an error if the second argument is not a version" do
+      knife.name_args = ["getting-started", "1pass"]
+      expect(knife.ui).to receive(:error).with("Installing multiple cookbooks at once is not supported.")
+      expect { knife.run }.to raise_error(SystemExit)
+    end
+
+    it "raises an error if the second argument is a four-digit version" do
+      knife.name_args = ["getting-started", "0.0.0.1"]
+      expect(knife.ui).to receive(:error).with("Installing multiple cookbooks at once is not supported.")
+      expect { knife.run }.to raise_error(SystemExit)
+    end
+
+    it "raises an error if the second argument is a one-digit version" do
+      knife.name_args = ["getting-started", "1"]
+      expect(knife.ui).to receive(:error).with("Installing multiple cookbooks at once is not supported.")
+      expect { knife.run }.to raise_error(SystemExit)
+    end
+
+    it "installs the specified version if second argument is a three-digit version" do
+      knife.name_args = ["getting-started", "0.1.0"]
+      knife.config[:no_deps] = true
+      upstream_file = File.join(install_path, "getting-started.tar.gz")
+      expect(knife).to receive(:download_cookbook_to).with(upstream_file)
+      expect(knife).to receive(:extract_cookbook).with(upstream_file, "0.1.0")
+      expect(knife).to receive(:clear_existing_files).with(File.join(install_path, "getting-started"))
+      expect(repo).to receive(:merge_updates_from).with("getting-started", "0.1.0")
+      knife.run
+    end
+
+    it "installs the specified version if second argument is a two-digit version" do
+      knife.name_args = ["getting-started", "0.1"]
+      knife.config[:no_deps] = true
+      upstream_file = File.join(install_path, "getting-started.tar.gz")
+      expect(knife).to receive(:download_cookbook_to).with(upstream_file)
+      expect(knife).to receive(:extract_cookbook).with(upstream_file, "0.1")
+      expect(knife).to receive(:clear_existing_files).with(File.join(install_path, "getting-started"))
+      expect(repo).to receive(:merge_updates_from).with("getting-started", "0.1")
+      knife.run
+    end
+
+    it "installs the latest version if only a cookbook name is given" do
+      knife.name_args = ["getting-started"]
+      knife.config[:no_deps] = true
+      upstream_file = File.join(install_path, "getting-started.tar.gz")
+      expect(knife).to receive(:download_cookbook_to).with(upstream_file)
+      expect(knife).to receive(:extract_cookbook).with(upstream_file, "0.3.0")
+      expect(knife).to receive(:clear_existing_files).with(File.join(install_path, "getting-started"))
+      expect(repo).to receive(:merge_updates_from).with("getting-started", "0.3.0")
+      knife.run
+    end
+
+    it "does not create/reset git branches if use_current_branch is set" do
+      knife.name_args = ["getting-started"]
+      knife.config[:use_current_branch] = true
+      knife.config[:no_deps] = true
+      upstream_file = File.join(install_path, "getting-started.tar.gz")
+      expect(repo).not_to receive(:prepare_to_import)
+      expect(repo).not_to receive(:reset_to_default_state)
+      knife.run
+    end
+
+    it "does not raise an error if cookbook_path is a string" do
+      knife.config[:cookbook_path] = install_path
+      knife.config[:no_deps] = true
+      knife.name_args = ["getting-started"]
+      upstream_file = File.join(install_path, "getting-started.tar.gz")
+      expect(knife).to receive(:download_cookbook_to).with(upstream_file)
+      expect(knife).to receive(:extract_cookbook).with(upstream_file, "0.3.0")
+      expect(knife).to receive(:clear_existing_files).with(File.join(install_path, "getting-started"))
+      expect(repo).to receive(:merge_updates_from).with("getting-started", "0.3.0")
+      expect { knife.run }.not_to raise_error
+    end
+  end # end of run
+
+  let(:metadata) { Chef::Cookbook::Metadata.new }
+  let(:rb_metadata_path) { File.join(install_path, "post-punk-kitchen", "metadata.rb") }
+  let(:json_metadata_path) { File.join(install_path, "post-punk-kitchen", "metadata.json") }
+
+  describe "preferred_metadata" do
+    before do
+      allow(Chef::Cookbook::Metadata).to receive(:new).and_return(metadata)
+      allow(File).to receive(:exist?).and_return(false)
+      knife.instance_variable_set(:@cookbook_name, "post-punk-kitchen")
+      knife.instance_variable_set(:@install_path, install_path)
+    end
+
+    it "returns a populated Metadata object if metadata.rb exists" do
+      allow(File).to receive(:exist?).with(rb_metadata_path).and_return(true)
+      expect(metadata).to receive(:from_file).with(rb_metadata_path)
+      knife.preferred_metadata
+    end
+
+    it "returns a populated Metadata object if metadata.json exists" do
+      allow(File).to receive(:exist?).with(json_metadata_path).and_return(true)
+      #expect(IO).to receive(:read).with(json_metadata_path)
+      allow(IO).to receive(:read)
+      expect(metadata).to receive(:from_json)
+      knife.preferred_metadata
+    end
+
+    it "prefers metadata.rb over metadata.json" do
+      allow(File).to receive(:exist?).with(rb_metadata_path).and_return(true)
+      allow(File).to receive(:exist?).with(json_metadata_path).and_return(true)
+      allow(IO).to receive(:read)
+      expect(metadata).to receive(:from_file).with(rb_metadata_path)
+      expect(metadata).not_to receive(:from_json)
+      knife.preferred_metadata
+    end
+
+    it "rasies an error if it finds no metadata file" do
+      expect { knife.preferred_metadata }.to raise_error { |error|
+        expect(error).to be_a(Chef::Exceptions::MetadataNotFound)
+        expect(error.cookbook_name).to eq("post-punk-kitchen")
+        expect(error.install_path).to eq(install_path)
+      }
+    end
+
+  end
+end