knife 17.0.244 → 17.2.15

data/spec/unit/knife/bootstrap/chef_vault_handler_spec.rb

@@ -0,0 +1,152 @@
+#
+# Author:: Lamont Granquist <lamont@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"
+
+describe Chef::Knife::Bootstrap::ChefVaultHandler do
+
+  let(:stdout) { StringIO.new }
+  let(:stderr) { StringIO.new }
+  let(:stdin) { StringIO.new }
+  let(:ui) { Chef::Knife::UI.new(stdout, stderr, stdin, {}) }
+
+  let(:config) { {} }
+
+  let(:client) { Chef::ApiClient.new }
+
+  let(:chef_vault_handler) do
+    chef_vault_handler = Chef::Knife::Bootstrap::ChefVaultHandler.new(config: config, ui: ui)
+    chef_vault_handler
+  end
+
+  context "when there's no vault option" do
+    it "should report its not doing anything" do
+      expect(chef_vault_handler.doing_chef_vault?).to be false
+    end
+
+    it "shouldn't do anything" do
+      expect(chef_vault_handler).to_not receive(:sanity_check)
+      expect(chef_vault_handler).to_not receive(:update_bootstrap_vault_json!)
+      chef_vault_handler
+    end
+  end
+
+  context "when setting chef vault items" do
+    let(:bootstrap_vault_item) { double("ChefVault::Item") }
+
+    before do
+      expect(chef_vault_handler).to receive(:require_chef_vault!).at_least(:once)
+      expect(bootstrap_vault_item).to receive(:clients).with(client).at_least(:once)
+      expect(bootstrap_vault_item).to receive(:save).at_least(:once)
+    end
+
+    context "from config[:bootstrap_vault_item]" do
+      it "sets a single item as a scalar" do
+        config[:bootstrap_vault_item] = { "vault" => "item1" }
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
+        chef_vault_handler.run(client)
+      end
+
+      it "sets a single item as an array" do
+        config[:bootstrap_vault_item] = { "vault" => [ "item1" ] }
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
+        chef_vault_handler.run(client)
+      end
+
+      it "sets two items as an array" do
+        config[:bootstrap_vault_item] = { "vault" => %w{item1 item2} }
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item2").and_return(bootstrap_vault_item)
+        chef_vault_handler.run(client)
+      end
+
+      it "sets two vaults from different hash keys" do
+        config[:bootstrap_vault_item] = { "vault" => %w{item1 item2}, "vault2" => [ "item3" ] }
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item2").and_return(bootstrap_vault_item)
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault2", "item3").and_return(bootstrap_vault_item)
+        chef_vault_handler.run(client)
+      end
+    end
+
+    context "from config[:bootstrap_vault_json]" do
+      it "sets a single item as a scalar" do
+        config[:bootstrap_vault_json] = '{ "vault": "item1" }'
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
+        chef_vault_handler.run(client)
+      end
+
+      it "sets a single item as an array" do
+        config[:bootstrap_vault_json] = '{ "vault": [ "item1" ] }'
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
+        chef_vault_handler.run(client)
+      end
+
+      it "sets two items as an array" do
+        config[:bootstrap_vault_json] = '{ "vault": [ "item1", "item2" ] }'
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item2").and_return(bootstrap_vault_item)
+        chef_vault_handler.run(client)
+      end
+
+      it "sets two vaults from different hash keys" do
+        config[:bootstrap_vault_json] = '{ "vault": [ "item1", "item2" ], "vault2": [ "item3" ] }'
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item2").and_return(bootstrap_vault_item)
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault2", "item3").and_return(bootstrap_vault_item)
+        chef_vault_handler.run(client)
+      end
+    end
+
+    context "from config[:bootstrap_vault_file]" do
+
+      def setup_file_contents(json)
+        stringio = StringIO.new(json)
+        config[:bootstrap_vault_file] = "/foo/bar/baz"
+        expect(File).to receive(:read).with(config[:bootstrap_vault_file]).and_return(stringio)
+      end
+
+      it "sets a single item as a scalar" do
+        setup_file_contents('{ "vault": "item1" }')
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
+        chef_vault_handler.run(client)
+      end
+
+      it "sets a single item as an array" do
+        setup_file_contents('{ "vault": [ "item1" ] }')
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
+        chef_vault_handler.run(client)
+      end
+
+      it "sets two items as an array" do
+        setup_file_contents('{ "vault": [ "item1", "item2" ] }')
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item2").and_return(bootstrap_vault_item)
+        chef_vault_handler.run(client)
+      end
+
+      it "sets two vaults from different hash keys" do
+        setup_file_contents('{ "vault": [ "item1", "item2" ], "vault2": [ "item3" ] }')
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item1").and_return(bootstrap_vault_item)
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault", "item2").and_return(bootstrap_vault_item)
+        expect(chef_vault_handler).to receive(:load_chef_bootstrap_vault_item).with("vault2", "item3").and_return(bootstrap_vault_item)
+        chef_vault_handler.run(client)
+      end
+    end
+  end
+end

data/spec/unit/knife/bootstrap/client_builder_spec.rb

@@ -0,0 +1,207 @@
+#
+# Author:: Lamont Granquist <lamont@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"
+
+describe Chef::Knife::Bootstrap::ClientBuilder do
+
+  let(:stdout) { StringIO.new }
+  let(:stderr) { StringIO.new }
+  let(:stdin) { StringIO.new }
+  let(:ui) { Chef::Knife::UI.new(stdout, stderr, stdin, {}) }
+
+  let(:config) { {} }
+
+  let(:chef_config) { {} }
+
+  let(:node_name) { "bevell.wat" }
+
+  let(:rest) { double("Chef::ServerAPI") }
+
+  let(:client_builder) do
+    client_builder = Chef::Knife::Bootstrap::ClientBuilder.new(config: config, chef_config: chef_config, ui: ui)
+    allow(client_builder).to receive(:rest).and_return(rest)
+    allow(client_builder).to receive(:node_name).and_return(node_name)
+    client_builder
+  end
+
+  context "#sanity_check!" do
+    let(:response_404) { OpenStruct.new(code: "404") }
+    let(:exception_404) { Net::HTTPClientException.new("404 not found", response_404) }
+
+    context "in cases where the prompting fails" do
+      before do
+        # should fail early in #run
+        expect(client_builder).to_not receive(:create_client!)
+        expect(client_builder).to_not receive(:create_node!)
+      end
+
+      it "exits when the node exists and the user does not want to delete" do
+        expect(rest).to receive(:get).with("nodes/#{node_name}")
+        expect(ui.stdin).to receive(:readline).and_return("n")
+        expect { client_builder.run }.to raise_error(SystemExit)
+      end
+
+      it "exits when the client exists and the user does not want to delete" do
+        expect(rest).to receive(:get).with("nodes/#{node_name}").and_raise(exception_404)
+        expect(rest).to receive(:get).with("clients/#{node_name}")
+        expect(ui.stdin).to receive(:readline).and_return("n")
+        expect { client_builder.run }.to raise_error(SystemExit)
+      end
+    end
+
+    context "in cases where the prompting succeeds" do
+      before do
+        # mock out the rest of #run
+        expect(client_builder).to receive(:create_client!)
+        expect(client_builder).to receive(:create_node!)
+      end
+
+      it "when both the client and node do not exist it succeeds" do
+        expect(rest).to receive(:get).with("nodes/#{node_name}").and_raise(exception_404)
+        expect(rest).to receive(:get).with("clients/#{node_name}").and_raise(exception_404)
+        expect { client_builder.run }.not_to raise_error
+      end
+
+      it "when we are allowed to delete an old node" do
+        expect(rest).to receive(:get).with("nodes/#{node_name}")
+        expect(ui.stdin).to receive(:readline).and_return("y")
+        expect(rest).to receive(:get).with("clients/#{node_name}").and_raise(exception_404)
+        expect(rest).to receive(:delete).with("nodes/#{node_name}")
+        expect { client_builder.run }.not_to raise_error
+      end
+
+      it "when we are allowed to delete an old client" do
+        expect(rest).to receive(:get).with("nodes/#{node_name}").and_raise(exception_404)
+        expect(rest).to receive(:get).with("clients/#{node_name}")
+        expect(ui.stdin).to receive(:readline).and_return("y")
+        expect(rest).to receive(:delete).with("clients/#{node_name}")
+        expect { client_builder.run }.not_to raise_error
+      end
+
+      it "when we are are allowed to delete both an old client and node" do
+        expect(rest).to receive(:get).with("nodes/#{node_name}")
+        expect(rest).to receive(:get).with("clients/#{node_name}")
+        expect(ui.stdin).to receive(:readline).twice.and_return("y")
+        expect(rest).to receive(:delete).with("nodes/#{node_name}")
+        expect(rest).to receive(:delete).with("clients/#{node_name}")
+        expect { client_builder.run }.not_to raise_error
+      end
+    end
+  end
+
+  context "#create_client!" do
+    let(:client) { Chef::ApiClient.new }
+
+    before do
+      # mock out the rest of #run
+      expect(client_builder).to receive(:sanity_check)
+      expect(client_builder).to receive(:create_node!)
+    end
+
+    it "delegates everything to Chef::ApiClient::Registration and sets client" do
+      reg_double = double("Chef::ApiClient::Registration")
+      expect(Chef::ApiClient::Registration).to receive(:new).with(node_name, client_builder.client_path, http_api: rest).and_return(reg_double)
+      expect(reg_double).to receive(:run).and_return(client)
+      client_builder.run
+      expect(client_builder.client).to eq(client)
+    end
+
+  end
+
+  context "#client_path" do
+    it "has a public API for the temporary client.pem file" do
+      expect(client_builder.client_path).to match(/#{node_name}.pem/)
+    end
+  end
+
+  context "#create_node!" do
+    before do
+      # mock out the rest of #run
+      expect(client_builder).to receive(:sanity_check)
+      expect(client_builder).to receive(:create_client!)
+      # mock out default node building steps
+      expect(client_builder).to receive(:client_rest).and_return(client_rest)
+      expect(Chef::Node).to receive(:new).with(chef_server_rest: client_rest).and_return(node)
+      expect(node).to receive(:name).with(node_name)
+      expect(node).to receive(:save)
+    end
+
+    let(:client_rest) { double("Chef::ServerAPI (client)") }
+
+    let(:node) { double("Chef::Node") }
+
+    it "builds a node with a default run_list of []" do
+      expect(node).to receive(:run_list).with([])
+      client_builder.run
+    end
+
+    it "does not add tags by default" do
+      allow(node).to receive(:run_list).with([])
+      expect(node).to_not receive(:tags)
+      client_builder.run
+    end
+
+    it "adds tags to the node when given" do
+      tag_receiver = []
+
+      config[:tags] = %w{foo bar}
+      allow(node).to receive(:run_list).with([])
+      allow(node).to receive(:tags).and_return(tag_receiver)
+      client_builder.run
+      expect(tag_receiver).to eq %w{foo bar}
+    end
+
+    it "builds a node when the run_list is a string" do
+      config[:run_list] = "role[base],role[app]"
+      expect(node).to receive(:run_list).with(["role[base]", "role[app]"])
+      client_builder.run
+    end
+
+    it "builds a node when the run_list is an Array" do
+      config[:run_list] = ["role[base]", "role[app]"]
+      expect(node).to receive(:run_list).with(["role[base]", "role[app]"])
+      client_builder.run
+    end
+
+    it "builds a node with first_boot_attributes if they're given" do
+      config[:first_boot_attributes] = { baz: :quux }
+      expect(node).to receive(:normal_attrs=).with({ baz: :quux })
+      expect(node).to receive(:run_list).with([])
+      client_builder.run
+    end
+
+    it "builds a node with an environment if its given" do
+      config[:environment] = "production"
+      expect(node).to receive(:environment).with("production")
+      expect(node).to receive(:run_list).with([])
+      client_builder.run
+    end
+
+    it "builds a node with policy_name and policy_group when given" do
+      config[:policy_name] = "my-app"
+      config[:policy_group] = "staging"
+
+      expect(node).to receive(:run_list).with([])
+      expect(node).to receive(:policy_name=).with("my-app")
+      expect(node).to receive(:policy_group=).with("staging")
+
+      client_builder.run
+    end
+  end
+end

data/spec/unit/knife/bootstrap/train_connector_spec.rb

@@ -0,0 +1,244 @@
+#
+# 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 "ostruct"
+require "chef/knife/bootstrap/train_connector"
+
+describe Chef::Knife::Bootstrap::TrainConnector do
+  let(:protocol) { "mock" }
+  let(:family) { "unknown" }
+  let(:release) { "unknown" } # version
+  let(:name) { "unknown" }
+  let(:arch) { "x86_64" }
+  let(:connection_opts) { {} } # connection opts
+  let(:host_url) { "mock://user1@example.com" }
+  let(:mock_connection) { true }
+
+  subject do
+    # Example groups can still override by setting explicitly it in 'connection_opts'
+    tc = Chef::Knife::Bootstrap::TrainConnector.new(host_url, protocol, connection_opts)
+    tc
+  end
+
+  before(:each) do
+    if mock_connection
+      subject.connect!
+      subject.connection.mock_os(
+        family: family,
+        name: name,
+        release: release,
+        arch: arch
+      )
+    end
+  end
+
+  describe "platform helpers" do
+    context "on linux" do
+      let(:family) { "debian" }
+      let(:name) { "ubuntu" }
+      it "reports that it is linux and unix, because that is how train classifies it" do
+        expect(subject.unix?).to eq true
+        expect(subject.linux?).to eq true
+        expect(subject.windows?).to eq false
+      end
+    end
+    context "on unix" do
+      let(:family) { "os" }
+      let(:name) { "mac_os_x" }
+      it "reports only a unix OS" do
+        expect(subject.unix?).to eq true
+        expect(subject.linux?).to eq false
+        expect(subject.windows?).to eq false
+      end
+    end
+    context "on windows" do
+      let(:family) { "windows" }
+      let(:name) { "windows" }
+      it "reports only a windows OS" do
+        expect(subject.unix?).to eq false
+        expect(subject.linux?).to eq false
+        expect(subject.windows?).to eq true
+      end
+    end
+  end
+
+  describe "#connect!" do
+    it "establishes the connection to the remote host by waiting for it" do
+      expect(subject.connection).to receive(:wait_until_ready)
+      subject.connect!
+    end
+  end
+
+  describe "#initialize" do
+    let(:mock_connection) { false }
+
+    context "when provided target is a proper URL" do
+      let(:protocol) { "ssh" }
+      let(:host_url) { "mock://user1@localhost:2200" }
+      it "correctly configures the instance from the URL" do
+        expect(subject.config[:backend]).to eq "mock"
+        expect(subject.config[:port]).to eq 2200
+        expect(subject.config[:host]).to eq "localhost"
+        expect(subject.config[:user]).to eq "user1"
+      end
+
+      context "and conflicting options are given" do
+        let(:connection_opts) { { user: "user2", host: "example.com", port: 15 } }
+        it "resolves them from the URI" do
+          expect(subject.config[:backend]).to eq "mock"
+          expect(subject.config[:port]).to eq 2200
+          expect(subject.config[:host]).to eq "localhost"
+          expect(subject.config[:user]).to eq "user1"
+        end
+      end
+    end
+
+    context "when provided target is just a hostname" do
+      let(:host_url) { "localhost" }
+      let(:protocol) { "mock" }
+      it "correctly sets backend protocol from the default" do
+        expect(subject.config[:backend]).to eq "mock"
+      end
+
+      context "and options have been provided that are supported by the transport" do
+        let(:protocol) { "ssh" }
+        let(:connection_opts) { { port: 15, user: "user2" } }
+
+        it "sets hostname and transport from arguments and provided fields from options" do
+          expect(subject.config[:backend]).to eq "ssh"
+          expect(subject.config[:host]).to eq "localhost"
+          expect(subject.config[:user]).to eq "user2"
+          expect(subject.config[:port]).to eq 15
+        end
+
+      end
+
+    end
+
+    context "when provided target is just a an IP address" do
+      let(:host_url) { "127.0.0.1" }
+      let(:protocol) { "mock" }
+      it "correctly sets backend protocol from the default" do
+        expect(subject.config[:backend]).to eq "mock"
+      end
+    end
+  end
+
+  describe "#temp_dir" do
+    context "under windows" do
+      let(:family) { "windows" }
+      let(:name) { "windows" }
+
+      it "uses the windows command to create the temp dir" do
+        expected_command = Chef::Knife::Bootstrap::TrainConnector::MKTEMP_WIN_COMMAND
+        expect(subject).to receive(:run_command!).with(expected_command)
+          .and_return double("result", stdout: "C:/a/path")
+        expect(subject.temp_dir).to eq "C:/a/path"
+      end
+
+    end
+    context "under linux and unix-like" do
+      let(:family) { "debian" }
+      let(:name) { "ubuntu" }
+      let(:random) { "wScHX6" }
+      let(:dir) { "/tmp/chef_#{random}" }
+
+      before do
+        allow(SecureRandom).to receive(:alphanumeric).with(6).and_return(random)
+      end
+
+      context "uses the *nix command to create the temp dir and sets ownership to logged-in" do
+        it "with sudo privilege" do
+          subject.config[:sudo] = true
+          expected_command1 = "mkdir -p '#{dir}'"
+          expected_command2 = "chown user1 '#{dir}'"
+          expect(subject).to receive(:run_command!).with(expected_command1)
+            .and_return double("result", stdout: "\r\n")
+          expect(subject).to receive(:run_command!).with(expected_command2)
+            .and_return double("result", stdout: "\r\n")
+          expect(subject.temp_dir).to eq(dir)
+        end
+
+        it "without sudo privilege" do
+          expected_command = "mkdir -p '#{dir}'"
+          expect(subject).to receive(:run_command!).with(expected_command)
+            .and_return double("result", stdout: "\r\n")
+          expect(subject.temp_dir).to eq(dir)
+        end
+      end
+
+      context "with noise in stderr" do
+        it "uses the *nix command to create the temp dir" do
+          expected_command = "mkdir -p '#{dir}'"
+          expect(subject).to receive(:run_command!).with(expected_command)
+            .and_return double("result", stdout: "sudo: unable to resolve host hostname.localhost\r\n" + "#{dir}\r\n")
+          expect(subject.temp_dir).to eq(dir)
+        end
+      end
+    end
+  end
+  context "#upload_file_content!" do
+    it "creates a local file with expected content and uploads it" do
+      expect(subject).to receive(:upload_file!) do |local_path, remote_path|
+        expect(File.read(local_path)).to eq "test data"
+        expect(remote_path).to eq "/target/path"
+      end
+      expect_any_instance_of(Tempfile).to receive(:binmode)
+      subject.upload_file_content!("test data", "/target/path")
+    end
+  end
+
+  context "del_file" do
+    context "on windows" do
+      let(:family) { "windows" }
+      let(:name) { "windows" }
+      it "deletes the file with a windows command" do
+        expect(subject).to receive(:run_command!) do |cmd, &_handler|
+          expect(cmd).to match(/Test-Path "deleteme\.txt".*/)
+        end
+        subject.del_file!("deleteme.txt")
+      end
+    end
+    context "on unix-like" do
+      let(:family) { "debian" }
+      let(:name) { "ubuntu" }
+      it "deletes the file with a windows command" do
+        expect(subject).to receive(:run_command!) do |cmd, &_handler|
+          expect(cmd).to match(/rm -f "deleteme\.txt".*/)
+        end
+        subject.del_file!("deleteme.txt")
+      end
+    end
+  end
+
+  context "#run_command!" do
+    it "raises a RemoteExecutionFailed when the remote execution failed" do
+      command_result = double("results", stdout: "", stderr: "failed", exit_status: 1)
+      expect(subject).to receive(:run_command).and_return command_result
+
+      expect { subject.run_command!("test") }.to raise_error do |e|
+        expect(e.hostname).to eq subject.hostname
+        expect(e.class).to eq Chef::Knife::Bootstrap::RemoteExecutionFailed
+        expect(e.stderr).to eq "failed"
+        expect(e.stdout).to eq ""
+        expect(e.exit_status).to eq 1
+      end
+    end
+  end
+
+end