chef 12.0.3 → 12.1.0.rc.0

data/spec/support/shared/functional/win32_service.rb

@@ -0,0 +1,60 @@
+
+require 'chef/application/windows_service_manager'
+
+shared_context "using Win32::Service" do
+  # Some helper methods.
+
+  def test_service_exists?
+    ::Win32::Service.exists?("spec-service")
+  end
+
+  def test_service_state
+    ::Win32::Service.status("spec-service").current_state
+  end
+
+  def service_manager
+    Chef::Application::WindowsServiceManager.new(test_service)
+  end
+
+  def cleanup
+    # Uninstall if the test service is installed.
+    if test_service_exists?
+
+      # We can only uninstall when the service is stopped.
+      if test_service_state != "stopped"
+        ::Win32::Service.send("stop", "spec-service")
+        while test_service_state != "stopped"
+          sleep 1
+        end
+      end
+
+      ::Win32::Service.delete("spec-service")
+    end
+
+    # Delete the test_service_file if it exists
+    if File.exists?(test_service_file)
+      File.delete(test_service_file)
+    end
+
+  end
+
+
+  # Definition for the test-service
+
+  let(:test_service) {
+    {
+      :service_name => "spec-service",
+      :service_display_name => "Spec Test Service",
+      :service_description => "Service for testing Chef::Application::WindowsServiceManager.",
+      :service_file_path => File.expand_path(File.join(File.dirname(__FILE__), '../../platforms/win32/spec_service.rb'))
+    }
+  }
+
+  # Test service creates a file for us to verify that it is running.
+  # Since our test service is running as Local System we should look
+  # for the file it creates under SYSTEM temp directory
+
+  let(:test_service_file) {
+    "#{ENV['SystemDrive']}\\windows\\temp\\spec_service_file"
+  }
+end

data/spec/support/shared/functional/windows_script.rb

@@ -83,29 +83,29 @@ shared_context Chef::Resource::WindowsScript do
 
       it "should create a process with the expected architecture" do
         resource.run_action(:run)
-        get_process_architecture.should == expected_architecture_output.downcase
+        expect(get_process_architecture).to eq(expected_architecture_output.downcase)
       end
 
       it "should execute guards with the same architecture as the resource" do
         resource.only_if resource_guard_command
         resource.run_action(:run)
-        get_process_architecture.should == expected_architecture_output.downcase
-        get_guard_process_architecture.should == expected_architecture_output.downcase
-        get_guard_process_architecture.should == get_process_architecture
+        expect(get_process_architecture).to eq(expected_architecture_output.downcase)
+        expect(get_guard_process_architecture).to eq(expected_architecture_output.downcase)
+        expect(get_guard_process_architecture).to eq(get_process_architecture)
       end
 
       let (:architecture) { :x86_64 }
       it "should execute a 64-bit guard if the guard's architecture is specified as 64-bit", :windows64_only do
         resource.only_if resource_guard_command, :architecture => :x86_64
         resource.run_action(:run)
-        get_guard_process_architecture.should == 'amd64'
+        expect(get_guard_process_architecture).to eq('amd64')
       end
 
       let (:architecture) { :i386 }
       it "should execute a 32-bit guard if the guard's architecture is specified as 32-bit" do
         resource.only_if resource_guard_command, :architecture => :i386
         resource.run_action(:run)
-        get_guard_process_architecture.should == 'x86'
+        expect(get_guard_process_architecture).to eq('x86')
       end
     end
   end
@@ -122,11 +122,11 @@ shared_context Chef::Resource::WindowsScript do
 
     context "when evaluating guards" do
       it "has a guard_interpreter attribute set to the short name of the resource" do
-        resource.guard_interpreter.should == resource.resource_name
+        expect(resource.guard_interpreter).to eq(resource.resource_name)
         resource.not_if "findstr.exe /thiscommandhasnonzeroexitstatus"
         expect(Chef::Resource).to receive(:resource_for_node).and_call_original
         expect(resource.class).to receive(:new).and_call_original
-        resource.should_skip?(:run).should be_false
+        expect(resource.should_skip?(:run)).to be_falsey
       end
     end
 

data/spec/support/shared/integration/knife_support.rb

@@ -103,6 +103,9 @@ module KnifeSupport
   private
 
   class KnifeResult
+
+    include ::RSpec::Matchers
+
     def initialize(stdout, stderr, exit_code)
       @stdout = stdout
       @stderr = stderr
@@ -150,20 +153,20 @@ module KnifeSupport
       stderr_actual = @stderr.sub(/^WARNING: No knife configuration file found\n/, '')
 
       if expected[:stderr].is_a?(Regexp)
-        stderr_actual.should =~ expected[:stderr]
+        expect(stderr_actual).to match(expected[:stderr])
       else
-        stderr_actual.should == expected[:stderr]
+        expect(stderr_actual).to eq(expected[:stderr])
       end
       stdout_actual = @stdout
       if Chef::Platform.windows?
         stderr_actual = stderr_actual.gsub("\r\n", "\n")
         stdout_actual = stdout_actual.gsub("\r\n", "\n")
       end
-      @exit_code.should == expected[:exit_code]
+      expect(@exit_code).to eq(expected[:exit_code])
       if expected[:stdout].is_a?(Regexp)
-        stdout_actual.should =~ expected[:stdout]
+        expect(stdout_actual).to match(expected[:stdout])
       else
-        stdout_actual.should == expected[:stdout]
+        expect(stdout_actual).to eq(expected[:stdout])
       end
     end
   end

data/spec/support/shared/matchers/exit_with_code.rb

@@ -12,12 +12,12 @@ RSpec::Matchers.define :exit_with_code do |exp_code|
     actual and actual == exp_code
   end
 
-  failure_message_for_should do |block|
+  failure_message do |block|
     "expected block to call exit(#{exp_code}) but exit" +
         (actual.nil? ? " not called" : "(#{actual}) was called")
   end
 
-  failure_message_for_should_not do |block|
+  failure_message_when_negated do |block|
     "expected block not to call exit(#{exp_code})"
   end
 
@@ -25,4 +25,8 @@ RSpec::Matchers.define :exit_with_code do |exp_code|
     "expect block to call exit(#{exp_code})"
   end
 
+  def supports_block_expectations?
+    true
+  end
+
 end

data/spec/support/shared/unit/api_error_inspector.rb

@@ -23,7 +23,7 @@
 # runs without error, but don't make assertions about the output. This is
 # because aspects such as how information gets formatted, what's included, etc.
 # are still in flux. When testing an inspector, change the outputter to use
-# STDOUT and manually check the ouput.
+# STDOUT and manually check the output.
 
 shared_examples_for "an api error inspector" do
 
@@ -72,7 +72,7 @@ shared_examples_for "an api error inspector" do
     before do
       @response_body = "synchronize the clock on your host"
       @response = Net::HTTPUnauthorized.new("1.1", "401", "(response) unauthorized")
-      @response.stub(:body).and_return(@response_body)
+      allow(@response).to receive(:body).and_return(@response_body)
       @exception = Net::HTTPServerException.new("(exception) unauthorized", @response)
       @inspector = described_class.new(@node_name, @exception, @config)
       @inspector.add_explanation(@description)
@@ -88,7 +88,7 @@ shared_examples_for "an api error inspector" do
     before do
       @response_body = "check your key and node name"
       @response = Net::HTTPUnauthorized.new("1.1", "401", "(response) unauthorized")
-      @response.stub(:body).and_return(@response_body)
+      allow(@response).to receive(:body).and_return(@response_body)
       @exception = Net::HTTPServerException.new("(exception) unauthorized", @response)
       @inspector = described_class.new(@node_name, @exception, @config)
       @inspector.add_explanation(@description)
@@ -104,7 +104,7 @@ shared_examples_for "an api error inspector" do
     before do
       @response_body = "forbidden"
       @response = Net::HTTPForbidden.new("1.1", "403", "(response) forbidden")
-      @response.stub(:body).and_return(@response_body)
+      allow(@response).to receive(:body).and_return(@response_body)
       @exception = Net::HTTPServerException.new("(exception) forbidden", @response)
       @inspector = described_class.new(@node_name, @exception, @config)
       @inspector.add_explanation(@description)
@@ -120,7 +120,7 @@ shared_examples_for "an api error inspector" do
     before do
       @response_body = "didn't like your data"
       @response = Net::HTTPBadRequest.new("1.1", "400", "(response) bad request")
-      @response.stub(:body).and_return(@response_body)
+      allow(@response).to receive(:body).and_return(@response_body)
       @exception = Net::HTTPServerException.new("(exception) bad request", @response)
       @inspector = described_class.new(@node_name, @exception, @config)
       @inspector.add_explanation(@description)
@@ -136,7 +136,7 @@ shared_examples_for "an api error inspector" do
     before do
       @response_body = "probably caused by a redirect to a get"
       @response = Net::HTTPNotFound.new("1.1", "404", "(response) not found")
-      @response.stub(:body).and_return(@response_body)
+      allow(@response).to receive(:body).and_return(@response_body)
       @exception = Net::HTTPServerException.new("(exception) not found", @response)
       @inspector = described_class.new(@node_name, @exception, @config)
       @inspector.add_explanation(@description)
@@ -151,7 +151,7 @@ shared_examples_for "an api error inspector" do
     before do
       @response_body = "sad trombone"
       @response = Net::HTTPInternalServerError.new("1.1", "500", "(response) internal server error")
-      @response.stub(:body).and_return(@response_body)
+      allow(@response).to receive(:body).and_return(@response_body)
       @exception = Net::HTTPFatalError.new("(exception) internal server error", @response)
       @inspector = described_class.new(@node_name, @exception, @config)
       @inspector.add_explanation(@description)
@@ -166,7 +166,7 @@ shared_examples_for "an api error inspector" do
     before do
       @response_body = "sad trombone orchestra"
       @response = Net::HTTPBadGateway.new("1.1", "502", "(response) bad gateway")
-      @response.stub(:body).and_return(@response_body)
+      allow(@response).to receive(:body).and_return(@response_body)
       @exception = Net::HTTPFatalError.new("(exception) bad gateway", @response)
       @inspector = described_class.new(@node_name, @exception, @config)
       @inspector.add_explanation(@description)

data/spec/support/shared/unit/execute_resource.rb

@@ -26,85 +26,89 @@ shared_examples_for "an execute resource" do
   end
 
   it "should create a new Chef::Resource::Execute" do
-    @resource.should be_a_kind_of(Chef::Resource)
-    @resource.should be_a_kind_of(Chef::Resource::Execute)
+    expect(@resource).to be_a_kind_of(Chef::Resource)
+    expect(@resource).to be_a_kind_of(Chef::Resource::Execute)
   end
 
   it "should set the command to the first argument to new" do
-    @resource.command.should eql(resource_instance_name)
+    expect(@resource.command).to eql(resource_instance_name)
   end
 
   it "should accept an array on instantiation, too" do
     resource = Chef::Resource::Execute.new(%w{something else})
-    resource.should be_a_kind_of(Chef::Resource)
-    resource.should be_a_kind_of(Chef::Resource::Execute)
-    resource.command.should eql(%w{something else})
+    expect(resource).to be_a_kind_of(Chef::Resource)
+    expect(resource).to be_a_kind_of(Chef::Resource::Execute)
+    expect(resource.command).to eql(%w{something else})
   end
 
   it "should accept a string for the command to run" do
     @resource.command "something"
-    @resource.command.should eql("something")
+    expect(@resource.command).to eql("something")
   end
 
   it "should accept an array for the command to run" do
     @resource.command %w{something else}
-    @resource.command.should eql(%w{something else})
+    expect(@resource.command).to eql(%w{something else})
   end
 
   it "should accept a string for the cwd" do
     @resource.cwd "something"
-    @resource.cwd.should eql("something")
+    expect(@resource.cwd).to eql("something")
   end
 
   it "should accept a hash for the environment" do
     test_hash = { :one => :two }
     @resource.environment(test_hash)
-    @resource.environment.should eql(test_hash)
+    expect(@resource.environment).to eql(test_hash)
   end
 
   it "allows the environment to be specified with #env" do
-    @resource.should respond_to(:env)
+    expect(@resource).to respond_to(:env)
   end
 
   it "should accept a string for the group" do
     @resource.group "something"
-    @resource.group.should eql("something")
+    expect(@resource.group).to eql("something")
   end
 
   it "should accept an integer for the group" do
     @resource.group 1
-    @resource.group.should eql(1)
+    expect(@resource.group).to eql(1)
   end
 
-  it "should accept an array for the execution path in Chef-12 and log deprecation message" do
+  it "should accept an array for the execution path in Chef-12 and log deprecation message", :chef_lt_13_only do
     expect(Chef::Log).to receive(:warn).at_least(:once)
     @resource.path ["woot"]
     expect(@resource.path).to eql(["woot"])
   end
 
+  it "should raise an exception in chef-13", :chef_gte_13_only do
+    expect(@resource.path [ "woot" ]).to raise_error
+  end
+
   it "should accept an integer for the return code" do
     @resource.returns 1
-    @resource.returns.should eql(1)
+    expect(@resource.returns).to eql(1)
   end
 
   it "should accept an integer for the timeout" do
     @resource.timeout 1
-    @resource.timeout.should eql(1)
+    expect(@resource.timeout).to eql(1)
   end
 
   it "should accept a string for the user" do
     @resource.user "something"
-    @resource.user.should eql("something")
+    expect(@resource.user).to eql("something")
   end
 
   it "should accept an integer for the user" do
     @resource.user 1
-    @resource.user.should eql(1)
+    expect(@resource.user).to eql(1)
   end
 
   it "should accept a string for creates" do
     @resource.creates "something"
-    @resource.creates.should eql("something")
+    expect(@resource.creates).to eql("something")
   end
 
   describe "when it has cwd, environment, group, path, return value, and a user" do
@@ -118,7 +122,7 @@ shared_examples_for "an execute resource" do
     end
 
     it "returns the command as its identity" do
-      @resource.identity.should == "grep"
+      expect(@resource.identity).to eq("grep")
     end
   end
 end

data/spec/support/shared/unit/file_system_support.rb

@@ -56,7 +56,7 @@ module FileSystemSupport
   def no_blocking_calls_allowed
     [ Chef::ChefFS::FileSystem::MemoryFile, Chef::ChefFS::FileSystem::MemoryDir ].each do |c|
       [ :children, :exists?, :read ].each do |m|
-        c.any_instance.stub(m).and_raise("#{m.to_s} should not be called")
+        allow_any_instance_of(c).to receive(m).and_raise("#{m.to_s} should not be called")
       end
     end
   end
@@ -64,7 +64,7 @@ module FileSystemSupport
   def list_should_yield_paths(fs, pattern_str, *expected_paths)
     result_paths = []
     Chef::ChefFS::FileSystem.list(fs, pattern(pattern_str)).each { |result| result_paths << result.path }
-    result_paths.should =~ expected_paths
+    expect(result_paths).to match_array(expected_paths)
   end
 end
 

data/spec/support/shared/unit/platform_introspector.rb

@@ -44,49 +44,49 @@ shared_examples_for "a platform introspector" do
 
   it "returns a default value when there is no known platform" do
     node = Hash.new
-    platform_introspector.value_for_platform(@platform_hash).should == "default"
+    expect(platform_introspector.value_for_platform(@platform_hash)).to eq("default")
   end
 
   it "returns a default value when there is no known platform family" do
-    platform_introspector.value_for_platform_family(@platform_family_hash).should == "default value"
+    expect(platform_introspector.value_for_platform_family(@platform_family_hash)).to eq("default value")
   end
 
   it "returns a default value when the current platform doesn't match" do
     node.automatic_attrs[:platform] = "not-a-known-platform"
-    platform_introspector.value_for_platform(@platform_hash).should == "default"
+    expect(platform_introspector.value_for_platform(@platform_hash)).to eq("default")
   end
 
   it "returns a default value when current platform_family doesn't match" do
     node.automatic_attrs[:platform_family] = "ultra-derived-linux"
-    platform_introspector.value_for_platform_family(@platform_family_hash).should == "default value"
+    expect(platform_introspector.value_for_platform_family(@platform_family_hash)).to eq("default value")
   end
 
   it "returns a value based on the current platform" do
     node.automatic_attrs[:platform] = "openbsd"
-    platform_introspector.value_for_platform(@platform_hash).should == "openbsd"
+    expect(platform_introspector.value_for_platform(@platform_hash)).to eq("openbsd")
   end
 
   it "returns a value based on the current platform family" do
     node.automatic_attrs[:platform_family] = "debian"
-    platform_introspector.value_for_platform_family(@platform_family_hash).should == "debian value"
+    expect(platform_introspector.value_for_platform_family(@platform_family_hash)).to eq("debian value")
   end
 
   it "returns a version-specific value based on the current platform" do
     node.automatic_attrs[:platform] = "openbsd"
     node.automatic_attrs[:platform_version] = "1.2.3"
-    platform_introspector.value_for_platform(@platform_hash).should == "openbsd-1.2.3"
+    expect(platform_introspector.value_for_platform(@platform_hash)).to eq("openbsd-1.2.3")
   end
 
   it "returns a value based on the current platform if version not found" do
     node.automatic_attrs[:platform] = "openbsd"
     node.automatic_attrs[:platform_version] = "0.0.0"
-    platform_introspector.value_for_platform(@platform_hash).should == "openbsd"
+    expect(platform_introspector.value_for_platform(@platform_hash)).to eq("openbsd")
   end
 
   it 'returns the exact match' do
     node.automatic_attrs[:platform] = 'exact_match'
     node.automatic_attrs[:platform_version] = '1.2.3'
-    platform_introspector.value_for_platform(@platform_hash).should == 'exact'
+    expect(platform_introspector.value_for_platform(@platform_hash)).to eq('exact')
   end
 
   it 'raises RuntimeError' do
@@ -98,20 +98,20 @@ shared_examples_for "a platform introspector" do
   it 'should return the value for that match' do
     node.automatic_attrs[:platform] = 'successful_matches'
     node.automatic_attrs[:platform_version] = '2.9'
-    platform_introspector.value_for_platform(@platform_hash).should == 'matched < 3.0'
+    expect(platform_introspector.value_for_platform(@platform_hash)).to eq('matched < 3.0')
   end
 
   describe "when platform versions is an array" do
     it "returns a version-specific value based on the current platform" do
       node.automatic_attrs[:platform] = "debian"
       node.automatic_attrs[:platform_version] = "6"
-      platform_introspector.value_for_platform(@platform_hash).should == "debian-5/6"
+      expect(platform_introspector.value_for_platform(@platform_hash)).to eq("debian-5/6")
     end
 
     it "returns a value based on the current platform if version not found" do
       node.automatic_attrs[:platform] = "debian"
       node.automatic_attrs[:platform_version] = "0.0.0"
-      platform_introspector.value_for_platform(@platform_hash).should == "debian"
+      expect(platform_introspector.value_for_platform(@platform_hash)).to eq("debian")
     end
   end
 
@@ -119,17 +119,17 @@ shared_examples_for "a platform introspector" do
 
     it "returns true if the node is a provided platform and platforms are provided as symbols" do
       node.automatic_attrs[:platform] = 'ubuntu'
-      platform_introspector.platform?([:redhat, :ubuntu]).should == true
+      expect(platform_introspector.platform?([:redhat, :ubuntu])).to eq(true)
     end
 
     it "returns true if the node is a provided platform and platforms are provided as strings" do
       node.automatic_attrs[:platform] = 'ubuntu'
-      platform_introspector.platform?(["redhat", "ubuntu"]).should == true
+      expect(platform_introspector.platform?(["redhat", "ubuntu"])).to eq(true)
     end
 
     it "returns false if the node is not of the provided platforms" do
       node.automatic_attrs[:platform] = 'ubuntu'
-      platform_introspector.platform?(:splatlinux).should == false
+      expect(platform_introspector.platform?(:splatlinux)).to eq(false)
     end
   end
 
@@ -137,21 +137,21 @@ shared_examples_for "a platform introspector" do
 
     it "returns true if the node is in a provided platform family and families are provided as symbols" do
       node.automatic_attrs[:platform_family] = 'debian'
-      platform_introspector.platform_family?([:rhel, :debian]).should == true
+      expect(platform_introspector.platform_family?([:rhel, :debian])).to eq(true)
     end
 
     it "returns true if the node is a provided platform and platforms are provided as strings" do
       node.automatic_attrs[:platform_family] = 'rhel'
-      platform_introspector.platform_family?(["rhel", "debian"]).should == true
+      expect(platform_introspector.platform_family?(["rhel", "debian"])).to eq(true)
     end
 
     it "returns false if the node is not of the provided platforms" do
       node.automatic_attrs[:platform_family] = 'suse'
-      platform_introspector.platform_family?(:splatlinux).should == false
+      expect(platform_introspector.platform_family?(:splatlinux)).to eq(false)
     end
 
     it "returns false if the node is not of the provided platforms and platform_family is not set" do
-      platform_introspector.platform_family?(:splatlinux).should == false
+      expect(platform_introspector.platform_family?(:splatlinux)).to eq(false)
     end
 
   end
@@ -170,13 +170,13 @@ shared_examples_for "a platform introspector" do
     it "returns the correct default for a given platform" do
       node.automatic_attrs[:platform] = "debian"
       node.automatic_attrs[:platform_version] = '9000'
-      platform_introspector.value_for_platform(@platform_hash).should == [ :restart, :reload, :status ]
+      expect(platform_introspector.value_for_platform(@platform_hash)).to eq([ :restart, :reload, :status ])
     end
 
     it "returns the correct platform+version specific value " do
       node.automatic_attrs[:platform] = "debian"
       node.automatic_attrs[:platform_version] = '4.0'
-      platform_introspector.value_for_platform(@platform_hash).should == [:restart, :reload]
+      expect(platform_introspector.value_for_platform(@platform_hash)).to eq([:restart, :reload])
     end
   end