chef 16.4.41-universal-mingw32 → 16.8.9-universal-mingw32

data/spec/unit/resource_inspector_spec.rb

@@ -33,9 +33,9 @@ class DummyResource < Chef::Resource
   end
 end
 
-describe ResourceInspector do
+describe Chef::ResourceInspector do
   describe "inspecting a resource" do
-    subject { ResourceInspector.extract_resource(DummyResource, false) }
+    subject { Chef::ResourceInspector.extract_resource(DummyResource, false) }
 
     it "returns a hash with required data" do
       expect(subject[:description]).to eq "A dummy resource"
@@ -50,7 +50,7 @@ describe ResourceInspector do
     end
 
     context "including built in properties" do
-      subject { ResourceInspector.extract_resource(DummyResource, true) }
+      subject { Chef::ResourceInspector.extract_resource(DummyResource, true) }
       it "returns many properties" do
         expect(subject[:properties].count).to be > 1
         expect(subject[:properties].map { |n| n[:name] }).to include(:name, :first, :sensitive)

data/spec/unit/run_lock_spec.rb

@@ -18,7 +18,11 @@
 require "spec_helper"
 require "chef/client"
 
-describe Chef::RunLock do
+# FIXME: these are disabled on MacOS due to timing issues in our anka build cluster
+# these issues should be fixed and the tests should be re-eenabled.  If we are getting
+# omnibus test phases on mac tests which are reasonable and not ~3 hours long, then the
+# condition to avoid this testing on macs can be deleted
+describe Chef::RunLock, :not_supported_on_macos do
 
   default_cache_path = windows? ? 'C:\chef' : "/var/chef"
   default_pid_location = windows? ? 'C:\chef\cache\chef-client-running.pid' : "/var/chef/cache/chef-client-running.pid"

data/spec/unit/runner_spec.rb

@@ -111,8 +111,7 @@ describe Chef::Runner do
 
     it "should use the provider specified by the resource (if it has one)" do
       provider = Chef::Provider::Easy.new(run_context.resource_collection[0], run_context)
-      # Expect provider to be called twice, because will fall back to old provider lookup
-      expect(run_context.resource_collection[0]).to receive(:provider).twice.and_return(Chef::Provider::Easy)
+      expect(run_context.resource_collection[0]).to receive(:provider).once.and_return(Chef::Provider::Easy)
       expect(Chef::Provider::Easy).to receive(:new).once.and_return(provider)
       runner.converge
     end

data/spec/unit/shell/shell_ext_spec.rb

@@ -19,14 +19,57 @@
 require "spec_helper"
 
 describe Shell::Extensions do
+  let(:test_shell_session) do
+    Class.new(Shell::ShellSession) do
+      def rebuild_node
+        nil
+      end
+
+      def rebuild_collection
+        nil
+      end
+
+      def loading
+        nil
+      end
+
+      def loading_complete
+        nil
+      end
+    end
+  end
+
+  let(:test_job_manager) do
+    Class.new do
+      attr_accessor :jobs
+    end
+  end
+
+  let(:object_test_harness) do
+    Proc.new do
+      extend Shell::Extensions::ObjectCoreExtensions
+
+      def conf=(new_conf)
+        @conf = new_conf
+      end
+
+      def conf
+        @conf
+      end
+
+      desc "rspecin'"
+      def rspec_method; end
+    end
+  end
+
   describe "extending object for top level methods" do
 
     before do
-      @shell_client = TestableShellSession.instance
+      @shell_client = test_shell_session.instance
       allow(Shell).to receive(:session).and_return(@shell_client)
-      @job_manager = TestJobManager.new
+      @job_manager = test_job_manager.new
       @root_context = Object.new
-      @root_context.instance_eval(&ObjectTestHarness)
+      @root_context.instance_eval(&object_test_harness)
       Shell::Extensions.extend_context_object(@root_context)
       @root_context.conf = double("irbconf")
     end

data/spec/unit/shell/shell_session_spec.rb

@@ -18,32 +18,10 @@
 require "spec_helper"
 require "ostruct"
 
-class TestableShellSession < Shell::ShellSession
-
-  def rebuild_node
-    nil
-  end
-
-  def rebuild_collection
-    nil
-  end
-
-  def loading
-    nil
-  end
-
-  def loading_complete
-    nil
-  end
-
-end
-
 describe Shell::ShellSession do
-
   it "is a singleton object" do
     expect(Shell::ShellSession).to include(Singleton)
   end
-
 end
 
 describe Shell::ClientSession do
@@ -120,20 +98,10 @@ end
 
 describe Shell::StandAloneSession do
   let(:json_attribs) { { "a" => "b" } }
-  let(:chef_rest) { double("Chef::ServerAPI") }
   let(:node) { Chef::Node.new }
-  let(:events) { Chef::EventDispatch::Dispatcher.new }
   let(:session) { Shell::StandAloneSession.instance }
-  let(:client) do
-    double("Chef::Client.new",
-      run_ohai: true,
-      load_node: true,
-      build_node: true,
-      register: true,
-      sync_cookbooks: {})
-  end
   let(:recipe) { Chef::Recipe.new(nil, nil, run_context) }
-  let(:run_context) { Chef::RunContext.new(node, {}, events) }
+  let(:run_context) { Chef::RunContext.new(node, {}, Chef::EventDispatch::Dispatcher.new) }
 
   before do
     Chef::Config[:shell_config] = { override_runlist: [Chef::RunList::RunListItem.new("shell::override")] }
@@ -172,6 +140,12 @@ describe Shell::StandAloneSession do
   end
 
   it "passes the shell CLI args to the client" do
+    client = double("Chef::Client.new",
+      run_ohai: true,
+      load_node: true,
+      build_node: true,
+      register: true,
+      sync_cookbooks: {})
     expect(Chef::Client).to receive(:new).with(json_attribs, Chef::Config[:shell_config]).and_return(client)
     session.send(:rebuild_node)
   end
@@ -180,68 +154,65 @@ end
 
 describe Shell::SoloLegacySession do
   let(:json_attribs) { { "a" => "b" } }
+  let(:node) { Chef::Node.new }
+  let(:session) { Shell::SoloLegacySession.instance }
+  let(:recipe) { Chef::Recipe.new(nil, nil, run_context) }
+  let(:run_context) { Chef::RunContext.new(node, {}, Chef::EventDispatch::Dispatcher.new) }
 
   before do
     Chef::Config[:shell_config] = { override_runlist: [Chef::RunList::RunListItem.new("shell::override")] }
-    Chef::Config[:shell_solo] = true
-    @session = Shell::SoloLegacySession.instance
-    @node = Chef::Node.new
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = @session.run_context = Chef::RunContext.new(@node, {}, @events)
-    @session.node = @node
-    @recipe = @session.recipe = Chef::Recipe.new(nil, nil, @run_context)
-    Shell::Extensions.extend_context_recipe(@recipe)
-  end
-
-  after do
-    Chef::Config[:shell_solo] = nil
+    Chef::Config[:solo_legacy_shell] = true
+    session.node = node
+    session.json_configuration = json_attribs
+    session.run_context = run_context
+    session.recipe = recipe
+    Shell::Extensions.extend_context_recipe(recipe)
   end
 
   it "returns a collection based on it's compilation object and the extra recipe provided by chef-shell" do
-    allow(@session).to receive(:node_built?).and_return(true)
+    allow(session).to receive(:node_built?).and_return(true)
     kitteh = Chef::Resource::Cat.new("keyboard")
-    @recipe.run_context.resource_collection << kitteh
-    expect(@session.resource_collection.include?(kitteh)).to be true
+    recipe.run_context.resource_collection << kitteh
+    expect(session.resource_collection.include?(kitteh)).to be true
   end
 
   it "returns definitions from its compilation object" do
-    expect(@session.definitions).to eq(@run_context.definitions)
+    expect(session.definitions).to eq(run_context.definitions)
   end
 
   it "keeps json attribs and passes them to the node for consumption" do
-    @session.node_attributes = { "besnard_lakes" => "are_the_dark_horse" }
-    expect(@session.node["besnard_lakes"]).to eq("are_the_dark_horse")
+    session.node_attributes = { "besnard_lakes" => "are_the_dark_horse" }
+    expect(session.node["besnard_lakes"]).to eq("are_the_dark_horse")
     # pending "1) keep attribs in an ivar 2) pass them to the node 3) feed them to the node on reset"
   end
 
   it "generates its resource collection from the compiled cookbooks and the ad hoc recipe" do
-    allow(@session).to receive(:node_built?).and_return(true)
+    allow(session).to receive(:node_built?).and_return(true)
     kitteh_cat = Chef::Resource::Cat.new("kitteh")
-    @run_context.resource_collection << kitteh_cat
+    run_context.resource_collection << kitteh_cat
     keyboard_cat = Chef::Resource::Cat.new("keyboard_cat")
-    @recipe.run_context.resource_collection << keyboard_cat
-    # @session.rebuild_collection
-    expect(@session.resource_collection.include?(kitteh_cat)).to be true
-    expect(@session.resource_collection.include?(keyboard_cat)).to be true
+    recipe.run_context.resource_collection << keyboard_cat
+    # session.rebuild_collection
+    expect(session.resource_collection.include?(kitteh_cat)).to be true
+    expect(session.resource_collection.include?(keyboard_cat)).to be true
   end
 
   it "runs chef with a resource collection from the compiled cookbooks" do
-    allow(@session).to receive(:node_built?).and_return(true)
+    allow(session).to receive(:node_built?).and_return(true)
     chef_runner = double("Chef::Runner.new", converge: :converged)
-    expect(Chef::Runner).to receive(:new).with(an_instance_of(Chef::RunContext)).and_return(chef_runner)
+    expect(Chef::Runner).to receive(:new).with(session.recipe.run_context).and_return(chef_runner)
 
-    expect(@recipe.run_chef).to eq(:converged)
+    expect(recipe.run_chef).to eq(:converged)
   end
 
   it "passes the shell CLI args to the client" do
-    @client = double("Chef::Client.new",
+    client = double("Chef::Client.new",
       run_ohai: true,
       load_node: true,
       build_node: true,
       register: true,
       sync_cookbooks: {})
-    expect(Chef::Client).to receive(:new).with(json_attribs, Chef::Config[:shell_config]).and_return(@client)
-    @session.json_configuration = json_attribs
-    @session.send(:rebuild_node)
+    expect(Chef::Client).to receive(:new).with(json_attribs, Chef::Config[:shell_config]).and_return(client)
+    session.send(:rebuild_node)
   end
 end

data/spec/unit/shell_spec.rb

@@ -18,26 +18,23 @@
 require "spec_helper"
 require "ostruct"
 
-ObjectTestHarness = Proc.new do
-  extend Shell::Extensions::ObjectCoreExtensions
-
-  def conf=(new_conf)
-    @conf = new_conf
-  end
-
-  def conf
-    @conf
-  end
+describe Shell do
+  let(:object_test_harness) do
+    Proc.new do
+      extend Shell::Extensions::ObjectCoreExtensions
 
-  desc "rspecin'"
-  def rspec_method; end
-end
+      def conf=(new_conf)
+        @conf = new_conf
+      end
 
-class TestJobManager
-  attr_accessor :jobs
-end
+      def conf
+        @conf
+      end
 
-describe Shell do
+      desc "rspecin'"
+      def rspec_method; end
+    end
+  end
 
   before do
     Shell.irb_conf = {}
@@ -66,7 +63,7 @@ describe Shell do
 
       conf = OpenStruct.new
       conf.main = Object.new
-      conf.main.instance_eval(&ObjectTestHarness)
+      conf.main.instance_eval(&object_test_harness)
       Shell.irb_conf[:IRB_RC].call(conf)
       expect(conf.prompt_c).to      eq("chef > ")
       expect(conf.return_format).to eq(" => %s \n")
@@ -107,7 +104,7 @@ describe Shell do
 
     before do
       @chef_object = Object.new
-      @chef_object.instance_eval(&ObjectTestHarness)
+      @chef_object.instance_eval(&object_test_harness)
     end
 
     it "creates help text for methods with descriptions" do
@@ -153,8 +150,8 @@ describe Shell do
     end
 
     it "creates a help banner with the command descriptions" do
-      expect(@chef_object.help_banner).to match(/^\|\ Command[\s]+\|\ Description[\s]*$/)
-      expect(@chef_object.help_banner).to match(/^\|\ rspec_method[\s]+\|\ rspecin\'[\s]*$/)
+      expect(@chef_object.help_banner).to match(/^\|\ Command\s+\|\ Description\s*$/)
+      expect(@chef_object.help_banner).to match(/^\|\ rspec_method\s+\|\ rspecin\'\s*$/)
     end
   end
 

data/spec/unit/train_transport_spec.rb

@@ -19,32 +19,33 @@
 require "spec_helper"
 
 describe Chef::TrainTransport do
+  let(:transport) { Chef::TrainTransport.new(Chef::Log) }
+
   describe "load_credentials" do
-    let(:transport) { Chef::TrainTransport.new }
     let(:good_credentials) { { "switch.cisco.com" => { "user" => "cisco", "password" => "cisco", "enable_password" => "secret" } } }
 
     before do
-      allow(Chef::TrainTransport).to receive(:parse_credentials_file).and_return(good_credentials)
+      allow(transport).to receive(:parse_credentials_file).and_return(good_credentials)
     end
 
     it "matches credentials when they exist" do
-      expect(Chef::TrainTransport.load_credentials("switch.cisco.com")[:user]).to eq("cisco")
-      expect(Chef::TrainTransport.load_credentials("switch.cisco.com")[:password]).to eq("cisco")
-      expect(Chef::TrainTransport.load_credentials("switch.cisco.com")[:enable_password]).to eq("secret")
+      expect(transport.load_credentials("switch.cisco.com")[:user]).to eq("cisco")
+      expect(transport.load_credentials("switch.cisco.com")[:password]).to eq("cisco")
+      expect(transport.load_credentials("switch.cisco.com")[:enable_password]).to eq("secret")
     end
 
     it "returns nil if there is no match" do
-      expect(Chef::TrainTransport.load_credentials("router.unicorns.com")).to be_nil
+      expect(transport.load_credentials("router.unicorns.com")).to be_nil
     end
 
     # [foo.example.org]   => {"foo"=>{"example"=>{"org"=>{}}}}
     # ['foo.example.org'] => {"foo.example.org"=>{}}
     it "warns if the host has been split by toml" do
-      allow(Chef::TrainTransport).to receive(:credentials_file_path).and_return("/Users/scotthourglass/.chef/credentials")
-      allow(Chef::TrainTransport).to receive(:parse_credentials_file).and_return({ "foo" => { "example" => { "org" => {} } } })
+      allow(transport).to receive(:credentials_file_path).and_return("/Users/scotthourglass/.chef/credentials")
+      allow(transport).to receive(:parse_credentials_file).and_return({ "foo" => { "example" => { "org" => {} } } })
       expect(Chef::Log).to receive(:warn).with(/as a Hash/)
       expect(Chef::Log).to receive(:warn).with(/Hostnames must be surrounded by single quotes/)
-      expect(Chef::TrainTransport.load_credentials("foo.example.org")).to be_nil
+      expect(transport.load_credentials("foo.example.org")).to be_nil
     end
   end
 
@@ -60,25 +61,25 @@ describe Chef::TrainTransport do
 
       it "returns the path if it exists" do
         allow(File).to receive(:exist?).with(config_cred_file_path).and_return(true)
-        expect(Chef::TrainTransport.credentials_file_path).to eq(config_cred_file_path)
+        expect(transport.credentials_file_path).to eq(config_cred_file_path)
       end
 
       it "raises an error if it does not exist" do
         allow(File).to receive(:exist?).and_return(false)
-        expect { Chef::TrainTransport.credentials_file_path }.to raise_error(ArgumentError, /does not exist/)
+        expect { transport.credentials_file_path }.to raise_error(ArgumentError, /does not exist/)
       end
     end
 
     it "raises an error if the default creds files do not exist" do
       allow(File).to receive(:exist?).and_return(false)
-      expect { Chef::TrainTransport.credentials_file_path }.to raise_error(ArgumentError, /does not exist/)
+      expect { transport.credentials_file_path }.to raise_error(ArgumentError, /does not exist/)
     end
 
     it "returns the path to the default config file if it exists" do
       tm_config = double("Config Context", host: "foo.example.org", credentials_file: nil)
       allow(Chef::Config).to receive(:target_mode).and_return(tm_config)
       allow(File).to receive(:exist?).with(host_cred_file_path).and_return(true)
-      expect(Chef::TrainTransport.credentials_file_path).to eq(host_cred_file_path)
+      expect(transport.credentials_file_path).to eq(host_cred_file_path)
     end
   end
 end

data/spec/unit/util/dsc/configuration_generator_spec.rb

@@ -25,6 +25,85 @@ describe Chef::Util::DSC::ConfigurationGenerator do
     Chef::Util::DSC::ConfigurationGenerator.new(node, "tmp")
   end
 
+  describe "#validate_switch_name!" do
+    it "should not raise an error if a name contains all upper case letters" do
+      conf_man.send(:validate_switch_name!, "HELLO")
+    end
+
+    it "should not raise an error if the name contains all lower case letters" do
+      conf_man.send(:validate_switch_name!, "hello")
+    end
+
+    it "should not raise an error if no special characters are used except _" do
+      conf_man.send(:validate_switch_name!, "hello_world")
+    end
+
+    %w{! @ # $ % ^ & * & * ( ) - = + \{ \} . ? < > \\ /}.each do |sym|
+      it "raises an ArgumentError if configuration name contains #{sym}" do
+        expect do
+          conf_man.send(:validate_switch_name!, "Hello#{sym}")
+        end.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "#escape_parameter_value" do
+    # Is this list really complete?
+    %w{` " # '}.each do |c|
+      it "escapes #{c}" do
+        expect(conf_man.send(:escape_parameter_value, "stuff #{c}")).to eql("stuff `#{c}")
+      end
+    end
+
+    it "does not do anything to a string without special characters" do
+      expect(conf_man.send(:escape_parameter_value, "stuff")).to eql("stuff")
+    end
+  end
+
+  describe "#escape_string_parameter_value" do
+    it "surrounds a string with ''" do
+      expect(conf_man.send(:escape_string_parameter_value, "stuff")).to eql("'stuff'")
+    end
+  end
+
+  describe "#command_switches_string" do
+    it "raises an ArgumentError if the key is not a symbol" do
+      expect do
+        conf_man.send(:command_switches_string, { "foo" => "bar" })
+      end.to raise_error(ArgumentError)
+    end
+
+    it "does not allow invalid switch names" do
+      expect do
+        conf_man.send(:command_switches_string, { foo!: "bar" })
+      end.to raise_error(ArgumentError)
+    end
+
+    it "ignores switches with a false value" do
+      expect(conf_man.send(:command_switches_string, { foo: false })).to eql("")
+    end
+
+    it "should correctly handle a value type of string" do
+      expect(conf_man.send(:command_switches_string, { foo: "bar" })).to eql("-foo 'bar'")
+    end
+
+    it "should correctly handle a value type of string even when it is 0 length" do
+      expect(conf_man.send(:command_switches_string, { foo: "" })).to eql("-foo ''")
+    end
+
+    it "should not quote integers" do
+      expect(conf_man.send(:command_switches_string, { foo: 1 })).to eql("-foo 1")
+    end
+
+    it "should not quote floats" do
+      expect(conf_man.send(:command_switches_string, { foo: 1.0 })).to eql("-foo 1.0")
+    end
+
+    it "has just the switch when the value is true" do
+      expect(conf_man.send(:command_switches_string, { foo: true })).to eql("-foo")
+    end
+  end
+
   describe "#validate_configuration_name!" do
     it "should not raise an error if a name contains all upper case letters" do
       conf_man.send(:validate_configuration_name!, "HELLO")