chef 12.16.42 → 12.17.44

data/spec/spec_helper.rb

@@ -68,6 +68,8 @@ require "chef/config"
 
 require "chef/chef_fs/file_system_cache"
 
+require "chef/api_client_v1"
+
 if ENV["CHEF_FIPS"] == "1"
   Chef::Config.init_openssl
 end
@@ -139,6 +141,7 @@ RSpec.configure do |config|
   config.filter_run_excluding :not_supported_on_gce => true if gce?
   config.filter_run_excluding :not_supported_on_nano => true if windows_nano_server?
   config.filter_run_excluding :win2k3_only => true unless windows_win2k3?
+  config.filter_run_excluding :win2012r2_only => true unless windows_2012r2?
   config.filter_run_excluding :windows_2008r2_or_later => true unless windows_2008r2_or_later?
   config.filter_run_excluding :windows64_only => true unless windows64?
   config.filter_run_excluding :windows32_only => true unless windows32?

data/spec/support/platform_helpers.rb

@@ -50,23 +50,31 @@ end
 
 def windows_win2k3?
   return false unless windows?
-  wmi = WmiLite::Wmi.new
-  host = wmi.first_of("Win32_OperatingSystem")
-  (host["version"] && host["version"].start_with?("5.2"))
+  (host_version && host_version.start_with?("5.2"))
 end
 
 def windows_2008r2_or_later?
   return false unless windows?
-  wmi = WmiLite::Wmi.new
-  host = wmi.first_of("Win32_OperatingSystem")
-  version = host["version"]
-  return false unless version
-  components = version.split(".").map do |component|
+  return false unless host_version
+  components = host_version.split(".").map do |component|
     component.to_i
   end
   components.length >= 2 && components[0] >= 6 && components[1] >= 1
 end
 
+def windows_2012r2?
+  return false unless windows?
+  (host_version && host_version.start_with?("6.3"))
+end
+
+def host_version
+  @host_version ||= begin
+    wmi = WmiLite::Wmi.new
+    host = wmi.first_of("Win32_OperatingSystem")
+    host["version"]
+  end
+end
+
 def windows_powershell_dsc?
   return false unless windows?
   supports_dsc = false

data/spec/unit/application/exit_code_spec.rb

@@ -77,11 +77,7 @@ describe Chef::Application::ExitCode do
     end
 
     it "writes a deprecation warning" do
-      warn = "Chef RFC 062 (https://github.com/chef/chef-rfc/master/rfc062-exit-status.md) defines the" \
-      " exit codes that should be used with Chef.  Chef::Application::ExitCode defines valid exit codes"  \
-      " In a future release, non-standard exit codes will be redefined as" \
-      " GENERIC_FAILURE unless `exit_status` is set to `:disabled` in your client.rb."
-      expect(Chef).to receive(:log_deprecation).with(warn)
+      expect(Chef).to receive(:deprecated).with(:exit_code, /^Chef RFC 062/)
       expect(exit_codes.normalize_exit_code(151)).to eq(151)
     end
 
@@ -118,11 +114,7 @@ describe Chef::Application::ExitCode do
     end
 
     it "does not write a deprecation warning" do
-      warn = "Chef RFC 062 (https://github.com/chef/chef-rfc/master/rfc062-exit-status.md) defines the" \
-      " exit codes that should be used with Chef.  Chef::Application::ExitCode defines valid exit codes"  \
-      " In a future release, non-standard exit codes will be redefined as" \
-      " GENERIC_FAILURE unless `exit_status` is set to `:disabled` in your client.rb."
-      expect(Chef).not_to receive(:log_deprecation).with(warn)
+      expect(Chef).not_to receive(:deprecated).with(:exit_code, /^Chef RFC 062/)
       expect(exit_codes.normalize_exit_code(151)).to eq(151)
     end
 
@@ -163,11 +155,7 @@ describe Chef::Application::ExitCode do
     end
 
     it "does write a deprecation warning" do
-      warn = "Chef RFC 062 (https://github.com/chef/chef-rfc/master/rfc062-exit-status.md) defines the" \
-      " exit codes that should be used with Chef.  Chef::Application::ExitCode defines valid exit codes"  \
-      " In a future release, non-standard exit codes will be redefined as" \
-      " GENERIC_FAILURE unless `exit_status` is set to `:disabled` in your client.rb."
-      expect(Chef).to receive(:log_deprecation).with(warn)
+      expect(Chef).to receive(:deprecated).with(:exit_code, /^Chef RFC 062/)
       expect(exit_codes.normalize_exit_code(151)).to eq(1)
     end
 

data/spec/unit/data_collector_spec.rb

@@ -371,12 +371,10 @@ describe Chef::DataCollector::Reporter do
     end
 
     context "when resource is not a nested resource" do
-      it "creates the resource report and stores it as the current one" do
+      it "initializes the resource report" do
         allow(reporter).to receive(:nested_resource?).and_return(false)
-        expect(reporter).to receive(:create_resource_report)
+        expect(reporter).to receive(:initialize_resource_report_if_needed)
           .with(new_resource, action, current_resource)
-          .and_return(resource_report)
-        expect(reporter).to receive(:update_current_resource_report).with(resource_report)
         reporter.resource_current_state_loaded(new_resource, action, current_resource)
       end
     end
@@ -418,7 +416,6 @@ describe Chef::DataCollector::Reporter do
 
     before do
       allow(reporter).to receive(:nested_resource?)
-      allow(reporter).to receive(:create_resource_report).and_return(resource_report)
       allow(resource_report).to receive(:skipped)
     end
 
@@ -431,17 +428,10 @@ describe Chef::DataCollector::Reporter do
     end
 
     context "when the resource is not a nested resource" do
-      it "creates the resource report and stores it as the current one" do
+      it "initializes the resource report and marks it as skipped" do
         allow(reporter).to receive(:nested_resource?).and_return(false)
-        expect(reporter).to receive(:create_resource_report)
-          .with(new_resource, action)
-          .and_return(resource_report)
-        expect(reporter).to receive(:update_current_resource_report).with(resource_report)
-        reporter.resource_skipped(new_resource, action, conditional)
-      end
-
-      it "marks the resource report as skipped" do
-        allow(reporter).to receive(:nested_resource?).with(new_resource).and_return(false)
+        allow(reporter).to receive(:current_resource_report).and_return(resource_report)
+        expect(reporter).to receive(:initialize_resource_report_if_needed).with(new_resource, action)
         expect(resource_report).to receive(:skipped).with(conditional)
         reporter.resource_skipped(new_resource, action, conditional)
       end
@@ -548,7 +538,7 @@ describe Chef::DataCollector::Reporter do
         end
 
         it "nils out the current resource report" do
-          expect(reporter).to receive(:update_current_resource_report).with(nil)
+          expect(reporter).to receive(:clear_current_resource_report)
           reporter.resource_completed(new_resource)
         end
       end

data/spec/unit/deprecated_spec.rb

@@ -0,0 +1,59 @@
+#
+# Copyright:: Copyright 2013-2016, 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 "spec_helper"
+require "chef/deprecated"
+
+describe Chef::Deprecated do
+  class TestDeprecation < Chef::Deprecated::Base
+    def id; 999; end
+
+    def target; "test.html"; end
+
+    def link; "#{Chef::Deprecated::Base::BASE_URL}test.html"; end
+  end
+
+  context "loading a deprecation class" do
+    it "loads the correct class" do
+      expect(Chef::Deprecated.create(:test_deprecation)).to be_an_instance_of(Chef::Deprecated::TestDeprecation)
+    end
+
+    it "optionally sets a message" do
+      deprecation = Chef::Deprecated.create(:test_deprecation, "A test message")
+      expect(deprecation.message).to eql("A test message")
+    end
+
+    it "optionally sets the location" do
+      deprecation = Chef::Deprecated.create(:test_deprecation, nil, "A test location")
+      expect(deprecation.location).to eql("A test location")
+    end
+  end
+
+  context "formatting deprecation warnings" do
+    let(:base_url) { Chef::Deprecated::Base::BASE_URL }
+    let(:message) { "A test message" }
+    let(:location) { "the location" }
+
+    it "displays the full URL" do
+      expect(Chef::Deprecated::TestDeprecation.new().url).to eql("#{base_url}test.html")
+    end
+
+    it "formats a complete deprecation message" do
+      expect(Chef::Deprecated::TestDeprecation.new(message, location).inspect).to eql("#{message} (CHEF-999)#{location}.\nhttps://docs.chef.io/deprecations_test.html")
+    end
+  end
+end

data/spec/unit/deprecation_spec.rb

@@ -65,15 +65,8 @@ describe Chef::Deprecation do
     end
 
     context "deprecation warning messages" do
-      RSpec::Matchers.define_negated_matcher :a_non_empty_array, :be_empty
-
       it "should be enabled for deprecated methods" do
-        expect(Chef::Log).to receive(:warn).with(a_non_empty_array)
-        TestClass.new.deprecated_method(10)
-      end
-
-      it "should contain stack trace" do
-        expect(Chef::Log).to receive(:warn).with(a_string_including(".rb"))
+        expect(Chef).to receive(:deprecated).with(:internal_api, /Method.*of 'TestClass'/)
         TestClass.new.deprecated_method(10)
       end
     end

data/spec/unit/handler_spec.rb

@@ -37,7 +37,7 @@ describe Chef::Handler do
       @run_status.exception = @exception
       @run_context = Chef::RunContext.new(@node, {}, @events)
       @all_resources = [Chef::Resource::Cat.new("lolz"), Chef::Resource::ZenMaster.new("tzu")]
-      @all_resources.first.updated = true
+      @all_resources.first.updated_by_last_action true
       @run_context.resource_collection.all_resources.replace(@all_resources)
       @run_status.run_context = @run_context
       @start_time = Time.now
@@ -118,7 +118,7 @@ describe Chef::Handler do
     before do
       @run_context = Chef::RunContext.new(@node, {}, @events)
       @all_resources = [Chef::Resource::Cat.new("foo"), Chef::Resource::ZenMaster.new("moo")]
-      @all_resources.first.updated = true
+      @all_resources.first.updated_by_last_action true
       @run_context.resource_collection.all_resources.replace(@all_resources)
       @run_status.run_context = @run_context
       @start_time = Time.now

data/spec/unit/knife/client_delete_spec.rb

@@ -34,6 +34,22 @@ describe Chef::Knife::ClientDelete do
       @knife.run
     end
 
+    context "receives multiple clients" do
+      let(:clients) { %w{ "adam", "ben", "charlie" } }
+
+      before(:each) do
+        @knife.name_args = clients
+      end
+
+      it "deletes all clients" do
+        clients.each do |client|
+          expect(@knife).to receive(:delete_object).with(Chef::ApiClientV1, client, "client")
+        end
+
+        @knife.run
+      end
+    end
+
     it "should print usage and exit when a client name is not provided" do
       @knife.name_args = []
       expect(@knife).to receive(:show_usage)

data/spec/unit/knife/configure_spec.rb

@@ -38,7 +38,7 @@ describe Chef::Knife::Configure do
   let(:default_validator_key) { "/etc/chef-server/chef-validator.pem" }
   let(:default_validator_key_win32) { File.expand_path(default_validator_key) }
 
-  let(:default_server_url) { "https://#{fqdn}:443" }
+  let(:default_server_url) { "https://#{fqdn}/organizations/myorg" }
 
   it "asks the user for the URL of the chef server" do
     @knife.ask_user_for_config

data/spec/unit/knife/cookbook_metadata_spec.rb

@@ -19,63 +19,96 @@
 require "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
-    @knife = Chef::Knife::CookbookMetadata.new
-    @knife.name_args = ["foobar"]
-    @cookbook_dir = Dir.mktmpdir
-    @json_data = '{ "version": "1.0.0" }'
-    @stdout = StringIO.new
-    @stderr = StringIO.new
-    allow(@knife.ui).to receive(:stdout).and_return(@stdout)
-    allow(@knife.ui).to receive(:stderr).and_return(@stderr)
+    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)
+      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)
+      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
+      expect(knife).to receive(:generate_metadata).with("foobar")
+      knife.run
     end
 
     describe "with -a or --all" do
       before(:each) do
-        @knife.config[:all] = true
-        @foo = Chef::CookbookVersion.new("foo", "/tmp/blah")
-        @foo.version = "1.0.0"
-        @bar = Chef::CookbookVersion.new("bar", "/tmp/blah")
-        @bar.version = "2.0.0"
-        @cookbook_loader = {
-          "foo" => @foo,
-          "bar" => @bar,
-        }
-        expect(@cookbook_loader).to receive(:load_cookbooks).and_return(@cookbook_loader)
-        expect(@knife).to receive(:generate_metadata).with("foo")
-        expect(@knife).to receive(:generate_metadata).with("bar")
+        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
-        Chef::Config[:cookbook_path] = @cookbook_dir
-        expect(Chef::CookbookLoader).to receive(:new).with(@cookbook_dir).and_return(@cookbook_loader)
-        @knife.run
+        expect(Chef::CookbookLoader).to receive(:new).with(cookbook_dir).and_call_original
+        knife.run
+        expect(stderr.string).to match /generating metadata for foo from #{cookbook_dir}\/foo\/metadata\.rb/im
+        expect(stderr.string).to match /generating metadata for bar from #{cookbook_dir}\/bar\/metadata\.rb/im
       end
 
-      describe "and with -o or --cookbook-path" do
-        it "should look in the provided path and generate cookbook metadata" do
-          @knife.config[:cookbook_path] = "/opt/chef/cookbooks"
-          expect(Chef::CookbookLoader).to receive(:new).with("/opt/chef/cookbooks").and_return(@cookbook_loader)
-          @knife.run
-        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 /generating metadata for foo from #{cookbook_dir}\/foo\/metadata\.rb/im
+        expect(stderr.string).to match /generating metadata for bar from #{cookbook_dir}\/bar\/metadata\.rb/im
       end
     end
 
@@ -83,97 +116,67 @@ describe Chef::Knife::CookbookMetadata do
 
   describe "generate_metadata" do
     before(:each) do
-      @knife.config[:cookbook_path] = @cookbook_dir
-      allow(File).to receive(:expand_path).with("#{@cookbook_dir}/foobar/metadata.rb").
-        and_return("#{@cookbook_dir}/foobar/metadata.rb")
+      Chef::Config[:cookbook_path] = cookbook_dir
     end
 
     it "should generate the metadata from metadata.rb if it exists" do
-      expect(File).to receive(:exists?).with("#{@cookbook_dir}/foobar/metadata.rb").
-        and_return(true)
-      expect(@knife).to receive(:generate_metadata_from_file).with("foobar", "#{@cookbook_dir}/foobar/metadata.rb")
-      @knife.run
+      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
-      expect(File).to receive(:exists?).with("#{@cookbook_dir}/foobar/metadata.rb").
-        and_return(false)
-      expect(@knife).to receive(:validate_metadata_json).with(@cookbook_dir, "foobar")
-      @knife.run
+      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 "generate_metadata_from_file" do
+  describe "validation errors" do
     before(:each) do
-      @metadata_mock = double("metadata")
-      @json_file_mock = double("json_file")
-    end
-
-    it "should generate the metatdata json from metatdata.rb" do
-      allow(Chef::Cookbook::Metadata).to receive(:new).and_return(@metadata_mock)
-      expect(@metadata_mock).to receive(:name).with("foobar")
-      expect(@metadata_mock).to receive(:from_file).with("#{@cookbook_dir}/foobar/metadata.rb")
-      expect(File).to receive(:open).with("#{@cookbook_dir}/foobar/metadata.json", "w").
-        and_yield(@json_file_mock)
-      expect(@json_file_mock).to receive(:write).with(@json_data)
-      expect(Chef::JSONCompat).to receive(:to_json_pretty).with(@metadata_mock).
-        and_return(@json_data)
-      @knife.generate_metadata_from_file("foobar", "#{@cookbook_dir}/foobar/metadata.rb")
-      expect(@stderr.string).to match /generating metadata for foobar from #{@cookbook_dir}\/foobar\/metadata\.rb/im
-    end
-
-    { Chef::Exceptions::ObsoleteDependencySyntax => "obsolote dependency",
-      Chef::Exceptions::InvalidVersionConstraint => "invalid version constraint",
-    }.each_pair do |klass, description|
-      it "should print an error and exit when an #{description} syntax exception is encountered" do
-        exception = klass.new("#{description} blah")
-        allow(Chef::Cookbook::Metadata).to receive(:new).and_raise(exception)
-        expect do
-          @knife.generate_metadata_from_file("foobar", "#{@cookbook_dir}/foobar/metadata.rb")
-        end.to raise_error(SystemExit)
-        expect(@stderr.string).to match /error: the cookbook 'foobar' contains invalid or obsolete metadata syntax/im
-        expect(@stderr.string).to match /in #{@cookbook_dir}\/foobar\/metadata\.rb/im
-        expect(@stderr.string).to match /#{description} blah/im
-      end
+      Chef::Config[:cookbook_path] = cookbook_dir
     end
-  end
 
-  describe "validate_metadata_json" do
-    it "should validate the metadata json" do
-      expect(File).to receive(:exist?).with("#{@cookbook_dir}/foobar/metadata.json").
-        and_return(true)
-      expect(IO).to receive(:read).with("#{@cookbook_dir}/foobar/metadata.json").
-        and_return(@json_data)
-      expect(Chef::Cookbook::Metadata).to receive(:validate_json).with(@json_data)
-      @knife.validate_metadata_json(@cookbook_dir, "foobar")
+    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 not try to validate the metadata json if the file does not exist" do
-      expect(File).to receive(:exist?).with("#{@cookbook_dir}/foobar/metadata.json").
-        and_return(false)
-      expect(IO).not_to receive(:read)
+    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)
-      @knife.validate_metadata_json(@cookbook_dir, "foobar")
-    end
-
-    { Chef::Exceptions::ObsoleteDependencySyntax => "obsolote dependency",
-      Chef::Exceptions::InvalidVersionConstraint => "invalid version constraint",
-    }.each_pair do |klass, description|
-      it "should print an error and exit when an #{description} syntax exception is encountered" do
-        expect(File).to receive(:exist?).with("#{@cookbook_dir}/foobar/metadata.json").
-          and_return(true)
-        expect(IO).to receive(:read).with("#{@cookbook_dir}/foobar/metadata.json").
-          and_return(@json_data)
-        exception = klass.new("#{description} blah")
-        allow(Chef::Cookbook::Metadata).to receive(:validate_json).and_raise(exception)
-        expect do
-          @knife.validate_metadata_json(@cookbook_dir, "foobar")
-        end.to raise_error(SystemExit)
-        expect(@stderr.string).to match /error: the cookbook 'foobar' contains invalid or obsolete metadata syntax/im
-        expect(@stderr.string).to match /in #{@cookbook_dir}\/foobar\/metadata\.json/im
-        expect(@stderr.string).to match /#{description} blah/im
-      end
+      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
-  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