knife 17.0.244 → 17.2.11

data/spec/unit/knife/cookbook_download_spec.rb

@@ -0,0 +1,255 @@
+#
+# Author:: Thomas Bishop (<bishop.thomas@gmail.com>)
+# Copyright:: Copyright 2011-2016, 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 "knife_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)
+
+        expect(Chef::CookbookVersion).to receive(:load).with("foobar", "1.0.0")
+          .and_return(cookbook)
+      end
+
+      let(:manifest_data) do
+        {
+          all_files: [
+            {
+              "path" => "recipes/foo.rb",
+              "name" => "recipes/foo.rb",
+              "url" => "http://example.org/files/foo.rb",
+            },
+            {
+              "path" => "recipes/bar.rb",
+              "name" => "recipes/bar.rb",
+              "url" => "http://example.org/files/bar.rb",
+            },
+            {
+              "path" => "templates/default/foo.erb",
+              "name" => "templates/foo.erb",
+              "url" => "http://example.org/files/foo.erb",
+            },
+            {
+              "path" => "templates/default/bar.erb",
+              "name" => "templates/bar.erb",
+              "url" => "http://example.org/files/bar.erb",
+            },
+            {
+              "path" => "attributes/default.rb",
+              "name" => "attributes/default.rb",
+              "url" => "http://example.org/files/default.rb",
+            },
+          ],
+        }
+      end
+
+      let(:cookbook) do
+        cb = Chef::CookbookVersion.new("foobar")
+        cb.version = "1.0.0"
+        cb.manifest = manifest_data
+        cb
+      end
+
+      describe "and no version" do
+        let(:manifest_data) { { all_files: [] } }
+        it "should determine which version to download" do
+          expect(@knife).to receive(:determine_version).and_return("1.0.0")
+          expect(File).to receive(:exist?).with("/var/tmp/chef/foobar-1.0.0").and_return(false)
+          @knife.run
+        end
+      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(:exist?).with("/var/tmp/chef/foobar-1.0.0").and_return(true)
+          expect(@knife.ui).to receive(:fatal).with(%r{/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(:streaming_request).with("http://example.org/files/#{file}")
+                .and_return(mock)
+            end
+
+            @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(:exist?).with("/var/tmp/chef/foobar-1.0.0").and_return(false)
+            @knife.run
+            %w{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 %r{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(:exist?).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 2011-2016, 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 "knife_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 = %w{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).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)
+        .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).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).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,72 @@
+#
+# Author:: Adam Jacob (<adam@chef.io>)
+# Author:: Matthew Kent (<mkent@magoazul.com>)
+# Copyright:: Copyright (c) Chef Software Inc.
+# Copyright:: Copyright (c) Chef Software 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 "knife_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.exist?(@tgt)
+      File.unlink(@tgt)
+    end
+  end
+
+  describe "run" do
+    it "should print usage and exit when a FILE is not provided" do
+      @knife.name_args = []
+      expect(@knife).to receive(:show_usage)
+      expect(@knife.ui).to receive(:fatal).with(/You must specify the FILE./)
+      expect { @knife.run }.to raise_error(SystemExit)
+    end
+
+    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,182 @@
+#
+# Author:: Thomas Bishop (<bishop.thomas@gmail.com>)
+# Copyright:: Copyright 2011-2016, 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 "knife_spec_helper"
+
+describe Chef::Knife::CookbookMetadata do
+  let(:knife) do
+    knife = Chef::Knife::CookbookMetadata.new
+    knife.name_args = ["foobar"]
+    knife
+  end
+
+  let(:cookbook_dir) { Dir.mktmpdir }
+
+  let(:stdout) { StringIO.new }
+
+  let(:stderr) { StringIO.new }
+
+  before(:each) do
+    allow(knife.ui).to receive(:stdout).and_return(stdout)
+    allow(knife.ui).to receive(:stderr).and_return(stderr)
+  end
+
+  def create_metadata_rb(**kwargs)
+    name = kwargs[:name]
+    Dir.mkdir("#{cookbook_dir}/#{name}")
+    File.open("#{cookbook_dir}/#{name}/metadata.rb", "w+") do |f|
+      kwargs.each do |key, value|
+        if value.is_a?(Array)
+          f.puts "#{key} #{value.map { |v| "\"#{v}\"" }.join(", ")}"
+        else
+          f.puts "#{key} \"#{value}\""
+        end
+      end
+    end
+  end
+
+  def create_metadata_json(**kwargs)
+    name = kwargs[:name]
+    Dir.mkdir("#{cookbook_dir}/#{name}")
+    File.open("#{cookbook_dir}/#{name}/metadata.json", "w+") do |f|
+      f.write(FFI_Yajl::Encoder.encode(kwargs))
+    end
+  end
+
+  def create_invalid_json
+    Dir.mkdir("#{cookbook_dir}/foobar")
+    File.open("#{cookbook_dir}/foobar/metadata.json", "w+") do |f|
+      f.write <<-EOH
+      { "version": "1.0.0", {ImInvalid}}
+      EOH
+    end
+  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
+        Chef::Config[:cookbook_path] = cookbook_dir
+        knife.config[:all] = true
+        create_metadata_rb(name: "foo", version: "1.0.0")
+        create_metadata_rb(name: "bar", version: "2.0.0")
+        expect(knife).to receive(:generate_metadata).with("foo").and_call_original
+        expect(knife).to receive(:generate_metadata).with("bar").and_call_original
+      end
+
+      it "should generate the metadata for each cookbook" do
+        expect(Chef::CookbookLoader).to receive(:new).with(cookbook_dir).and_call_original
+        knife.run
+        expect(stderr.string).to match %r{generating metadata for foo from #{cookbook_dir}/foo/metadata\.rb}im
+        expect(stderr.string).to match %r{generating metadata for bar from #{cookbook_dir}/bar/metadata\.rb}im
+      end
+
+      it "with -o or --cookbook_path should look in the provided path and generate cookbook metadata" do
+        Chef::Config[:cookbook_path] = "/dev/null"
+        knife.config[:cookbook_path] = cookbook_dir
+        expect(Chef::CookbookLoader).to receive(:new).with(cookbook_dir).and_call_original
+        knife.run
+        expect(stderr.string).to match %r{generating metadata for foo from #{cookbook_dir}/foo/metadata\.rb}im
+        expect(stderr.string).to match %r{generating metadata for bar from #{cookbook_dir}/bar/metadata\.rb}im
+      end
+    end
+
+  end
+
+  describe "generate_metadata" do
+    before(:each) do
+      Chef::Config[:cookbook_path] = cookbook_dir
+    end
+
+    it "should generate the metadata from metadata.rb if it exists" do
+      create_metadata_rb(name: "foobar", version: "1.0.0")
+      expect(knife).to receive(:generate_metadata_from_file).with("foobar", "#{cookbook_dir}/foobar/metadata.rb").and_call_original
+      knife.run
+      expect(File.exist?("#{cookbook_dir}/foobar/metadata.json")).to be true
+      json = FFI_Yajl::Parser.parse(IO.read("#{cookbook_dir}/foobar/metadata.json"))
+      expect(json["name"]).to eql("foobar")
+      expect(json["version"]).to eql("1.0.0")
+    end
+
+    it "should validate the metadata json if metadata.rb does not exist" do
+      create_metadata_json(name: "foobar", version: "1.0.0")
+      expect(knife).to receive(:validate_metadata_json).with(cookbook_dir, "foobar").and_call_original
+      knife.run
+    end
+  end
+
+  describe "validation errors" do
+    before(:each) do
+      Chef::Config[:cookbook_path] = cookbook_dir
+    end
+
+    it "should fail for obsolete operators in metadata.rb" do
+      create_metadata_rb(name: "foobar", version: "1.0.0", depends: [ "foo:bar", ">> 0.2" ])
+      expect(Chef::Cookbook::Metadata).not_to receive(:validate_json)
+      expect { knife.run }.to raise_error(SystemExit)
+      expect(stderr.string).to match(/error: the cookbook 'foobar' contains invalid or obsolete metadata syntax/im)
+    end
+
+    it "should fail for obsolete format in metadata.rb (sadly)" do
+      create_metadata_rb(name: "foobar", version: "1.0.0", depends: [ "foo:bar", "> 0.2", "< 1.0" ])
+      expect(Chef::Cookbook::Metadata).not_to receive(:validate_json)
+      expect { knife.run }.to raise_error(SystemExit)
+      expect(stderr.string).to match(/error: the cookbook 'foobar' contains invalid or obsolete metadata syntax/im)
+    end
+
+    it "should fail for obsolete operators in metadata.json" do
+      create_metadata_json(name: "foobar", version: "1.0.0", dependencies: { "foo:bar" => ">> 0.2" })
+      expect { knife.run }.to raise_error(SystemExit)
+      expect(stderr.string).to match(/error: the cookbook 'foobar' contains invalid or obsolete metadata syntax/im)
+    end
+
+    it "should not fail for unknown field in metadata.rb" do
+      create_metadata_rb(name: "sounders", version: "2.0.0", beats: "toronto")
+      expect(Chef::Cookbook::Metadata).not_to receive(:validate_json)
+      expect { knife.run }.not_to raise_error
+      expect(stderr.string).to eql("")
+    end
+
+    it "should not fail for unknown field in metadata.json" do
+      create_metadata_json(name: "sounders", version: "2.0.0", beats: "toronto")
+      expect { knife.run }.not_to raise_error
+      expect(stderr.string).to eql("")
+    end
+
+    it "should fail on unparsable json" do
+      create_invalid_json
+      expect { knife.run }.to raise_error(Chef::Exceptions::JSON::ParseError)
+    end
+  end
+end