knife 17.0.246 → 17.1.35

data/spec/unit/knife/status_spec.rb

@@ -0,0 +1,112 @@
+#
+# Author:: Sahil Muthoo (<sahil.muthoo@gmail.com>)
+# 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::Status do
+  before(:each) do
+    node = Chef::Node.new.tap do |n|
+      n.automatic_attrs["fqdn"] = "foobar"
+      n.automatic_attrs["ohai_time"] = 1343845969
+      n.automatic_attrs["platform"] = "mac_os_x"
+      n.automatic_attrs["platform_version"] = "10.12.5"
+    end
+    allow(Time).to receive(:now).and_return(Time.at(1428573420))
+    @query = double("Chef::Search::Query")
+    allow(@query).to receive(:search).and_yield(node)
+    allow(Chef::Search::Query).to receive(:new).and_return(@query)
+    @knife = Chef::Knife::Status.new
+    @stdout = StringIO.new
+    allow(@knife.ui).to receive(:stdout).and_return(@stdout)
+  end
+
+  describe "run" do
+    let(:opts) do
+      { filter_result:
+                 { name: ["name"], ipaddress: ["ipaddress"], ohai_time: ["ohai_time"],
+                   cloud: ["cloud"], run_list: ["run_list"], platform: ["platform"],
+                   platform_version: ["platform_version"], chef_environment: ["chef_environment"] } }
+    end
+
+    it "should default to searching for everything" do
+      expect(@query).to receive(:search).with(:node, "*:*", opts)
+      @knife.run
+    end
+
+    it "should filter by nodes older than some mins" do
+      @knife.config[:hide_by_mins] = 59
+      expect(@query).to receive(:search).with(:node, "NOT ohai_time:[1428569880 TO 1428573420]", opts)
+      @knife.run
+    end
+
+    it "should filter by environment" do
+      @knife.config[:environment] = "production"
+      expect(@query).to receive(:search).with(:node, "chef_environment:production", opts)
+      @knife.run
+    end
+
+    it "should filter by environment and nodes older than some mins" do
+      @knife.config[:environment] = "production"
+      @knife.config[:hide_by_mins] = 59
+      expect(@query).to receive(:search).with(:node, "chef_environment:production NOT ohai_time:[1428569880 TO 1428573420]", opts)
+      @knife.run
+    end
+
+    it "should not use partial search with long output" do
+      @knife.config[:long_output] = true
+      expect(@query).to receive(:search).with(:node, "*:*", {})
+      @knife.run
+    end
+
+    context "with a custom query" do
+      before :each do
+        @knife.instance_variable_set(:@name_args, ["name:my_custom_name"])
+      end
+
+      it "should allow a custom query to be specified" do
+        expect(@query).to receive(:search).with(:node, "name:my_custom_name", opts)
+        @knife.run
+      end
+
+      it "should filter by nodes older than some mins with nodename specified" do
+        @knife.config[:hide_by_mins] = 59
+        expect(@query).to receive(:search).with(:node, "name:my_custom_name NOT ohai_time:[1428569880 TO 1428573420]", opts)
+        @knife.run
+      end
+
+      it "should filter by environment with nodename specified" do
+        @knife.config[:environment] = "production"
+        expect(@query).to receive(:search).with(:node, "name:my_custom_name AND chef_environment:production", opts)
+        @knife.run
+      end
+
+      it "should filter by environment and nodes older than some mins with nodename specified" do
+        @knife.config[:environment] = "production"
+        @knife.config[:hide_by_mins] = 59
+        expect(@query).to receive(:search).with(:node, "name:my_custom_name AND chef_environment:production NOT ohai_time:[1428569880 TO 1428573420]", opts)
+        @knife.run
+      end
+    end
+
+    it "should not colorize output unless it's writing to a tty" do
+      @knife.run
+      expect(@stdout.string.match(/foobar/)).not_to be_nil
+      expect(@stdout.string.match(/\e.*ago/)).to be_nil
+    end
+  end
+end

data/spec/unit/knife/supermarket_download_spec.rb

@@ -0,0 +1,152 @@
+#
+# Author:: Thomas Bishop (<bishop.thomas@gmail.com>)
+# Copyright:: Copyright 2012-2016, Thomas Bishop
+# 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 "chef/knife/supermarket_download"
+require "knife_spec_helper"
+
+describe Chef::Knife::SupermarketDownload do
+
+  describe "run" do
+    before do
+      @knife            = Chef::Knife::SupermarketDownload.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.tr ".", "_"
+      @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)
+        .with("#{@cookbook_api_url}/apache2")
+        .and_return(@current_data)
+      @knife.configure_chef
+    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")
+      end
+
+      context "downloading the latest version" do
+        before do
+          expect(@noauth_rest).to receive(:get)
+            .with(@current_data["latest_version"])
+            .and_return(@cookbook_data)
+          expect(@noauth_rest).to receive(:streaming_request)
+            .with(@cookbook_data["file"])
+            .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.tr ".", "_"
+          @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)
+            .with("#{@cookbook_api_url}/apache2/versions/#{@version_us}")
+            .and_return(@cookbook_data)
+          expect(@noauth_rest).to receive(:streaming_request)
+            .with(@cookbook_data["file"])
+            .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/supermarket_install_spec.rb

@@ -0,0 +1,203 @@
+#
+# Author:: Steven Danna (<steve@chef.io>)
+# 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"
+require "chef/knife/supermarket_install"
+require "mixlib/archive"
+
+describe Chef::Knife::SupermarketInstall do
+  let(:knife) { Chef::Knife::SupermarketInstall.new }
+  let(:stdout) { StringIO.new }
+  let(:stderr) { StringIO.new }
+  let(:downloader) { {} }
+  let(:archive) { double(Mixlib::Archive, extract: true) }
+  let(:repo) do
+    double(sanity_check: true, reset_to_default_state: true,
+           prepare_to_import: true, finalize_updates_to: true,
+           merge_updates_from: true)
+  end
+  let(:install_path) do
+    if ChefUtils.windows?
+      "C:/tmp/chef"
+    else
+      "/var/tmp/chef"
+    end
+  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)
+    allow(Mixlib::Archive).to receive(:new).and_return(archive)
+
+    # SupermarketDownload Setup
+    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 = %w{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 = %w{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 = %w{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