knife 18.6.13 → 18.7.9

data/spec/unit/knife/data_bag_secret_options_spec.rb

@@ -1,173 +1,173 @@
-#
-# Author:: Tyler Ball (<tball@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"
-require "chef/config"
-require "tempfile"
-
-class ExampleDataBagCommand < Chef::Knife
-  include Chef::Knife::DataBagSecretOptions
-end
-
-describe Chef::Knife::DataBagSecretOptions do
-  let(:example_db) do
-    k = ExampleDataBagCommand.new
-    allow(k.ui).to receive(:stdout).and_return(stdout)
-    k
-  end
-
-  let(:stdout) { StringIO.new }
-
-  let(:secret) { "abc123SECRET" }
-  let(:secret_file) do
-    sfile = Tempfile.new("encrypted_data_bag_secret")
-    sfile.puts(secret)
-    sfile.flush
-    sfile
-  end
-
-  after do
-    secret_file.close
-    secret_file.unlink
-  end
-
-  describe "#validate_secrets" do
-
-    it "throws an error when provided with both --secret and --secret-file on the CL" do
-      example_db.config[:cl_secret_file] = secret_file.path
-      example_db.config[:cl_secret] = secret
-      expect(example_db).to receive(:exit).with(1)
-      expect(example_db.ui).to receive(:fatal).with("Please specify only one of --secret, --secret-file")
-
-      example_db.validate_secrets
-    end
-
-    it "throws an error when provided with `secret` and `secret_file` in knife.rb" do
-      Chef::Config[:knife][:secret_file] = secret_file.path
-      Chef::Config[:knife][:secret] = secret
-      example_db.merge_configs
-      expect(example_db).to receive(:exit).with(1)
-      expect(example_db.ui).to receive(:fatal).with("Please specify only one of 'secret' or 'secret_file' in your config file")
-
-      example_db.validate_secrets
-    end
-
-  end
-
-  describe "#read_secret" do
-
-    it "returns the secret first" do
-      example_db.config[:cl_secret] = secret
-      Chef::Config[:knife][:secret] = secret
-      example_db.merge_configs
-      expect(example_db.read_secret).to eq(secret)
-    end
-
-    it "returns the secret_file only if secret does not exist" do
-      example_db.config[:cl_secret_file] = secret_file.path
-      Chef::Config[:knife][:secret_file] = secret_file.path
-      example_db.merge_configs
-      expect(Chef::EncryptedDataBagItem).to receive(:load_secret).with(secret_file.path).and_return("secret file contents")
-      expect(example_db.read_secret).to eq("secret file contents")
-    end
-
-    it "returns the secret from the knife.rb config" do
-      Chef::Config[:knife][:secret_file] = secret_file.path
-      Chef::Config[:knife][:secret] = secret
-      example_db.merge_configs
-      expect(example_db.read_secret).to eq(secret)
-    end
-
-    it "returns the secret_file from the knife.rb config only if the secret does not exist" do
-      Chef::Config[:knife][:secret_file] = secret_file.path
-      example_db.merge_configs
-      expect(Chef::EncryptedDataBagItem).to receive(:load_secret).with(secret_file.path).and_return("secret file contents")
-      expect(example_db.read_secret).to eq("secret file contents")
-    end
-
-  end
-
-  describe "#encryption_secret_provided?" do
-
-    it "returns true if the secret is passed on the CL" do
-      example_db.config[:cl_secret] = secret
-      expect(example_db.encryption_secret_provided?).to eq(true)
-    end
-
-    it "returns true if the secret_file is passed on the CL" do
-      example_db.config[:cl_secret_file] = secret_file.path
-      expect(example_db.encryption_secret_provided?).to eq(true)
-    end
-
-    it "returns true if --encrypt is passed on the CL and :secret is in config" do
-      example_db.config[:encrypt] = true
-      Chef::Config[:knife][:secret] = secret
-      example_db.merge_configs
-      expect(example_db.encryption_secret_provided?).to eq(true)
-    end
-
-    it "returns true if --encrypt is passed on the CL and :secret_file is in config" do
-      example_db.config[:encrypt] = true
-      Chef::Config[:knife][:secret_file] = secret_file.path
-      example_db.merge_configs
-      expect(example_db.encryption_secret_provided?).to eq(true)
-    end
-
-    it "throws an error if --encrypt is passed and there is not :secret or :secret_file in the config" do
-      example_db.config[:encrypt] = true
-      expect(example_db).to receive(:exit).with(1)
-      expect(example_db.ui).to receive(:fatal).with("No secret or secret_file specified in config, unable to encrypt item.")
-      example_db.encryption_secret_provided?
-    end
-
-    it "returns false if no secret is passed" do
-      expect(example_db.encryption_secret_provided?).to eq(false)
-    end
-
-    it "returns false if --encrypt is not provided and :secret is in the config" do
-      Chef::Config[:knife][:secret] = secret
-      example_db.merge_configs
-      expect(example_db.encryption_secret_provided?).to eq(false)
-    end
-
-    it "returns false if --encrypt is not provided and :secret_file is in the config" do
-      Chef::Config[:knife][:secret_file] = secret_file.path
-      example_db.merge_configs
-      expect(example_db.encryption_secret_provided?).to eq(false)
-    end
-
-    it "returns true if --encrypt is not provided, :secret is in the config and need_encrypt_flag is false" do
-      Chef::Config[:knife][:secret] = secret
-      example_db.merge_configs
-      expect(example_db.encryption_secret_provided_ignore_encrypt_flag?).to eq(true)
-    end
-
-    it "returns true if --encrypt is not provided, :secret_file is in the config and need_encrypt_flag is false" do
-      Chef::Config[:knife][:secret_file] = secret_file.path
-      example_db.merge_configs
-      expect(example_db.encryption_secret_provided_ignore_encrypt_flag?).to eq(true)
-    end
-
-    it "returns false if --encrypt is not provided and need_encrypt_flag is false" do
-      expect(example_db.encryption_secret_provided_ignore_encrypt_flag?).to eq(false)
-    end
-
-  end
-
-end
+#
+# Author:: Tyler Ball (<tball@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"
+require "chef/config"
+require "tempfile"
+
+class ExampleDataBagCommand < Chef::Knife
+  include Chef::Knife::DataBagSecretOptions
+end
+
+describe Chef::Knife::DataBagSecretOptions do
+  let(:example_db) do
+    k = ExampleDataBagCommand.new
+    allow(k.ui).to receive(:stdout).and_return(stdout)
+    k
+  end
+
+  let(:stdout) { StringIO.new }
+
+  let(:secret) { "abc123SECRET" }
+  let(:secret_file) do
+    sfile = Tempfile.new("encrypted_data_bag_secret")
+    sfile.puts(secret)
+    sfile.flush
+    sfile
+  end
+
+  after do
+    secret_file.close
+    secret_file.unlink
+  end
+
+  describe "#validate_secrets" do
+
+    it "throws an error when provided with both --secret and --secret-file on the CL" do
+      example_db.config[:cl_secret_file] = secret_file.path
+      example_db.config[:cl_secret] = secret
+      expect(example_db).to receive(:exit).with(1)
+      expect(example_db.ui).to receive(:fatal).with("Please specify only one of --secret, --secret-file")
+
+      example_db.validate_secrets
+    end
+
+    it "throws an error when provided with `secret` and `secret_file` in knife.rb" do
+      Chef::Config[:knife][:secret_file] = secret_file.path
+      Chef::Config[:knife][:secret] = secret
+      example_db.merge_configs
+      expect(example_db).to receive(:exit).with(1)
+      expect(example_db.ui).to receive(:fatal).with("Please specify only one of 'secret' or 'secret_file' in your config file")
+
+      example_db.validate_secrets
+    end
+
+  end
+
+  describe "#read_secret" do
+
+    it "returns the secret first" do
+      example_db.config[:cl_secret] = secret
+      Chef::Config[:knife][:secret] = secret
+      example_db.merge_configs
+      expect(example_db.read_secret).to eq(secret)
+    end
+
+    it "returns the secret_file only if secret does not exist" do
+      example_db.config[:cl_secret_file] = secret_file.path
+      Chef::Config[:knife][:secret_file] = secret_file.path
+      example_db.merge_configs
+      expect(Chef::EncryptedDataBagItem).to receive(:load_secret).with(secret_file.path).and_return("secret file contents")
+      expect(example_db.read_secret).to eq("secret file contents")
+    end
+
+    it "returns the secret from the knife.rb config" do
+      Chef::Config[:knife][:secret_file] = secret_file.path
+      Chef::Config[:knife][:secret] = secret
+      example_db.merge_configs
+      expect(example_db.read_secret).to eq(secret)
+    end
+
+    it "returns the secret_file from the knife.rb config only if the secret does not exist" do
+      Chef::Config[:knife][:secret_file] = secret_file.path
+      example_db.merge_configs
+      expect(Chef::EncryptedDataBagItem).to receive(:load_secret).with(secret_file.path).and_return("secret file contents")
+      expect(example_db.read_secret).to eq("secret file contents")
+    end
+
+  end
+
+  describe "#encryption_secret_provided?" do
+
+    it "returns true if the secret is passed on the CL" do
+      example_db.config[:cl_secret] = secret
+      expect(example_db.encryption_secret_provided?).to eq(true)
+    end
+
+    it "returns true if the secret_file is passed on the CL" do
+      example_db.config[:cl_secret_file] = secret_file.path
+      expect(example_db.encryption_secret_provided?).to eq(true)
+    end
+
+    it "returns true if --encrypt is passed on the CL and :secret is in config" do
+      example_db.config[:encrypt] = true
+      Chef::Config[:knife][:secret] = secret
+      example_db.merge_configs
+      expect(example_db.encryption_secret_provided?).to eq(true)
+    end
+
+    it "returns true if --encrypt is passed on the CL and :secret_file is in config" do
+      example_db.config[:encrypt] = true
+      Chef::Config[:knife][:secret_file] = secret_file.path
+      example_db.merge_configs
+      expect(example_db.encryption_secret_provided?).to eq(true)
+    end
+
+    it "throws an error if --encrypt is passed and there is not :secret or :secret_file in the config" do
+      example_db.config[:encrypt] = true
+      expect(example_db).to receive(:exit).with(1)
+      expect(example_db.ui).to receive(:fatal).with("No secret or secret_file specified in config, unable to encrypt item.")
+      example_db.encryption_secret_provided?
+    end
+
+    it "returns false if no secret is passed" do
+      expect(example_db.encryption_secret_provided?).to eq(false)
+    end
+
+    it "returns false if --encrypt is not provided and :secret is in the config" do
+      Chef::Config[:knife][:secret] = secret
+      example_db.merge_configs
+      expect(example_db.encryption_secret_provided?).to eq(false)
+    end
+
+    it "returns false if --encrypt is not provided and :secret_file is in the config" do
+      Chef::Config[:knife][:secret_file] = secret_file.path
+      example_db.merge_configs
+      expect(example_db.encryption_secret_provided?).to eq(false)
+    end
+
+    it "returns true if --encrypt is not provided, :secret is in the config and need_encrypt_flag is false" do
+      Chef::Config[:knife][:secret] = secret
+      example_db.merge_configs
+      expect(example_db.encryption_secret_provided_ignore_encrypt_flag?).to eq(true)
+    end
+
+    it "returns true if --encrypt is not provided, :secret_file is in the config and need_encrypt_flag is false" do
+      Chef::Config[:knife][:secret_file] = secret_file.path
+      example_db.merge_configs
+      expect(example_db.encryption_secret_provided_ignore_encrypt_flag?).to eq(true)
+    end
+
+    it "returns false if --encrypt is not provided and need_encrypt_flag is false" do
+      expect(example_db.encryption_secret_provided_ignore_encrypt_flag?).to eq(false)
+    end
+
+  end
+
+end

data/spec/unit/knife/data_bag_show_spec.rb

@@ -1,139 +1,139 @@
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# Author:: Seth Falcon (<seth@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/data_bag_item"
-require "chef/encrypted_data_bag_item"
-require "chef/json_compat"
-require "tempfile"
-
-describe Chef::Knife::DataBagShow do
-
-  before do
-    Chef::Config[:node_name] = "webmonkey.example.com"
-    knife.name_args = [bag_name, item_name]
-    allow(knife).to receive(:config).and_return(config)
-  end
-
-  let(:knife) do
-    k = Chef::Knife::DataBagShow.new
-    allow(k).to receive(:rest).and_return(rest)
-    allow(k.ui).to receive(:stdout).and_return(stdout)
-    k
-  end
-
-  let(:rest) { double("Chef::ServerAPI") }
-  let(:stdout) { StringIO.new }
-
-  let(:bag_name) { "sudoing_admins" }
-  let(:item_name) { "ME" }
-
-  let(:data_bag_contents) do
-    { "id" => "id", "baz" => "http://localhost:4000/data/bag_o_data/baz",
-      "qux" => "http://localhost:4000/data/bag_o_data/qux" }
-  end
-  let(:enc_hash) { Chef::EncryptedDataBagItem.encrypt_data_bag_item(data_bag_contents, secret) }
-  let(:data_bag) { Chef::DataBagItem.from_hash(data_bag_contents) }
-  let(:data_bag_with_encoded_hash) { Chef::DataBagItem.from_hash(enc_hash) }
-  let(:enc_data_bag) { Chef::EncryptedDataBagItem.new(enc_hash, secret) }
-
-  let(:secret) { "abc123SECRET" }
-  #
-  # let(:raw_hash)  {{ "login_name" => "alphaomega", "id" => item_name }}
-  #
-  let(:config) { { format: "json" } }
-
-  context "Data bag to show is encrypted" do
-    before do
-      allow(knife).to receive(:encrypted?).and_return(true)
-    end
-
-    it "decrypts and displays the encrypted data bag when the secret is provided" do
-      expect(knife).to receive(:encryption_secret_provided_ignore_encrypt_flag?).and_return(true)
-      expect(knife).to receive(:read_secret).and_return(secret)
-      expect(Chef::DataBagItem).to receive(:load).with(bag_name, item_name).and_return(data_bag_with_encoded_hash)
-      expect(knife.ui).to receive(:info).with("Encrypted data bag detected, decrypting with provided secret.")
-      expect(Chef::EncryptedDataBagItem).to receive(:load).with(bag_name, item_name, secret).and_return(enc_data_bag)
-
-      expected = %q{baz: http://localhost:4000/data/bag_o_data/baz
-id:  id
-qux: http://localhost:4000/data/bag_o_data/qux}
-      knife.run
-      expect(stdout.string.strip).to eq(expected)
-    end
-
-    it "displays the encrypted data bag when the secret is not provided" do
-      expect(knife).to receive(:encryption_secret_provided_ignore_encrypt_flag?).and_return(false)
-      expect(Chef::DataBagItem).to receive(:load).with(bag_name, item_name).and_return(data_bag_with_encoded_hash)
-      expect(knife.ui).to receive(:warn).with("Encrypted data bag detected, but no secret provided for decoding. Displaying encrypted data.")
-
-      knife.run
-      expect(stdout.string.strip).to include("baz", "qux", "cipher")
-    end
-  end
-
-  context "Data bag to show is not encrypted" do
-    before do
-      allow(knife).to receive(:encrypted?).and_return(false)
-    end
-
-    it "displays the data bag" do
-      expect(knife).to receive(:read_secret).exactly(0).times
-      expect(Chef::DataBagItem).to receive(:load).with(bag_name, item_name).and_return(data_bag)
-
-      expected = %q{baz: http://localhost:4000/data/bag_o_data/baz
-id:  id
-qux: http://localhost:4000/data/bag_o_data/qux}
-      knife.run
-      expect(stdout.string.strip).to eq(expected)
-    end
-
-    context "when a secret is given" do
-      it "displays the data bag" do
-        expect(knife).to receive(:encryption_secret_provided_ignore_encrypt_flag?).and_return(true)
-        expect(knife).to receive(:read_secret).and_return(secret)
-        expect(Chef::DataBagItem).to receive(:load).with(bag_name, item_name).and_return(data_bag)
-        expect(knife.ui).to receive(:warn).with("Unencrypted data bag detected, ignoring any provided secret options.")
-
-        expected = %q{baz: http://localhost:4000/data/bag_o_data/baz
-id:  id
-qux: http://localhost:4000/data/bag_o_data/qux}
-        knife.run
-        expect(stdout.string.strip).to eq(expected)
-      end
-    end
-  end
-
-  it "displays the list of items in the data bag when only one @name_arg is provided" do
-    knife.name_args = [bag_name]
-    expect(Chef::DataBag).to receive(:load).with(bag_name).and_return({})
-
-    knife.run
-    expect(stdout.string.strip).to eq("")
-  end
-
-  it "raises an error when no @name_args are provided" do
-    knife.name_args = []
-
-    expect { knife.run }.to exit_with_code(1)
-    expect(stdout.string).to start_with("knife data bag show BAG [ITEM] (options)")
-  end
-
-end
+#
+# Author:: Adam Jacob (<adam@chef.io>)
+# Author:: Seth Falcon (<seth@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/data_bag_item"
+require "chef/encrypted_data_bag_item"
+require "chef/json_compat"
+require "tempfile"
+
+describe Chef::Knife::DataBagShow do
+
+  before do
+    Chef::Config[:node_name] = "webmonkey.example.com"
+    knife.name_args = [bag_name, item_name]
+    allow(knife).to receive(:config).and_return(config)
+  end
+
+  let(:knife) do
+    k = Chef::Knife::DataBagShow.new
+    allow(k).to receive(:rest).and_return(rest)
+    allow(k.ui).to receive(:stdout).and_return(stdout)
+    k
+  end
+
+  let(:rest) { double("Chef::ServerAPI") }
+  let(:stdout) { StringIO.new }
+
+  let(:bag_name) { "sudoing_admins" }
+  let(:item_name) { "ME" }
+
+  let(:data_bag_contents) do
+    { "id" => "id", "baz" => "http://localhost:4000/data/bag_o_data/baz",
+      "qux" => "http://localhost:4000/data/bag_o_data/qux" }
+  end
+  let(:enc_hash) { Chef::EncryptedDataBagItem.encrypt_data_bag_item(data_bag_contents, secret) }
+  let(:data_bag) { Chef::DataBagItem.from_hash(data_bag_contents) }
+  let(:data_bag_with_encoded_hash) { Chef::DataBagItem.from_hash(enc_hash) }
+  let(:enc_data_bag) { Chef::EncryptedDataBagItem.new(enc_hash, secret) }
+
+  let(:secret) { "abc123SECRET" }
+  #
+  # let(:raw_hash)  {{ "login_name" => "alphaomega", "id" => item_name }}
+  #
+  let(:config) { { format: "json" } }
+
+  context "Data bag to show is encrypted" do
+    before do
+      allow(knife).to receive(:encrypted?).and_return(true)
+    end
+
+    it "decrypts and displays the encrypted data bag when the secret is provided" do
+      expect(knife).to receive(:encryption_secret_provided_ignore_encrypt_flag?).and_return(true)
+      expect(knife).to receive(:read_secret).and_return(secret)
+      expect(Chef::DataBagItem).to receive(:load).with(bag_name, item_name).and_return(data_bag_with_encoded_hash)
+      expect(knife.ui).to receive(:info).with("Encrypted data bag detected, decrypting with provided secret.")
+      expect(Chef::EncryptedDataBagItem).to receive(:load).with(bag_name, item_name, secret).and_return(enc_data_bag)
+
+      expected = %q{baz: http://localhost:4000/data/bag_o_data/baz
+id:  id
+qux: http://localhost:4000/data/bag_o_data/qux}
+      knife.run
+      expect(stdout.string.strip).to eq(expected)
+    end
+
+    it "displays the encrypted data bag when the secret is not provided" do
+      expect(knife).to receive(:encryption_secret_provided_ignore_encrypt_flag?).and_return(false)
+      expect(Chef::DataBagItem).to receive(:load).with(bag_name, item_name).and_return(data_bag_with_encoded_hash)
+      expect(knife.ui).to receive(:warn).with("Encrypted data bag detected, but no secret provided for decoding. Displaying encrypted data.")
+
+      knife.run
+      expect(stdout.string.strip).to include("baz", "qux", "cipher")
+    end
+  end
+
+  context "Data bag to show is not encrypted" do
+    before do
+      allow(knife).to receive(:encrypted?).and_return(false)
+    end
+
+    it "displays the data bag" do
+      expect(knife).to receive(:read_secret).exactly(0).times
+      expect(Chef::DataBagItem).to receive(:load).with(bag_name, item_name).and_return(data_bag)
+
+      expected = %q{baz: http://localhost:4000/data/bag_o_data/baz
+id:  id
+qux: http://localhost:4000/data/bag_o_data/qux}
+      knife.run
+      expect(stdout.string.strip).to eq(expected)
+    end
+
+    context "when a secret is given" do
+      it "displays the data bag" do
+        expect(knife).to receive(:encryption_secret_provided_ignore_encrypt_flag?).and_return(true)
+        expect(knife).to receive(:read_secret).and_return(secret)
+        expect(Chef::DataBagItem).to receive(:load).with(bag_name, item_name).and_return(data_bag)
+        expect(knife.ui).to receive(:warn).with("Unencrypted data bag detected, ignoring any provided secret options.")
+
+        expected = %q{baz: http://localhost:4000/data/bag_o_data/baz
+id:  id
+qux: http://localhost:4000/data/bag_o_data/qux}
+        knife.run
+        expect(stdout.string.strip).to eq(expected)
+      end
+    end
+  end
+
+  it "displays the list of items in the data bag when only one @name_arg is provided" do
+    knife.name_args = [bag_name]
+    expect(Chef::DataBag).to receive(:load).with(bag_name).and_return({})
+
+    knife.run
+    expect(stdout.string.strip).to eq("")
+  end
+
+  it "raises an error when no @name_args are provided" do
+    knife.name_args = []
+
+    expect { knife.run }.to exit_with_code(1)
+    expect(stdout.string).to start_with("knife data bag show BAG [ITEM] (options)")
+  end
+
+end