chef 11.14.0.alpha.2-x86-mingw32 → 11.14.0.alpha.3-x86-mingw32

data/spec/integration/knife/redirection_spec.rb

@@ -16,6 +16,7 @@
 # limitations under the License.
 
 require 'support/shared/integration/integration_helper'
+require 'support/shared/context/config'
 require 'chef/knife/list'
 
 describe 'redirection' do
@@ -23,13 +24,15 @@ describe 'redirection' do
   include KnifeSupport
   include AppServerSupport
 
+  include_context "default config options"
+
   when_the_chef_server 'has a role' do
     role 'x', {}
 
     context 'and another server redirects to it with 302' do
       before :each do
         real_chef_server_url = Chef::Config.chef_server_url
-        Chef::Config.chef_server_url = "http://127.0.0.1:9018"
+        Chef::Config.chef_server_url = "http://localhost:9018"
         app = lambda do |env|
           [302, {'Content-Type' => 'text','Location' => "#{real_chef_server_url}#{env['PATH_INFO']}" }, ['302 found'] ]
         end

data/spec/integration/knife/serve_spec.rb

@@ -0,0 +1,57 @@
+#
+# Author:: John Keiser (<jkeiser@opscode.com>)
+# Copyright:: Copyright (c) 2013 Opscode, 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 'support/shared/integration/integration_helper'
+require 'chef/knife/serve'
+require 'chef/server_api'
+
+describe 'knife serve' do
+  extend IntegrationSupport
+  include KnifeSupport
+  include AppServerSupport
+
+  when_the_repository 'also has one of each thing' do
+    file 'nodes/x.json', { 'foo' => 'bar' }
+
+    it 'knife serve serves up /nodes/x' do
+      exception = nil
+      t = Thread.new do
+        begin
+          knife('serve')
+        rescue
+          exception = $!
+        end
+      end
+      begin
+        Chef::Config.log_level = :debug
+        Chef::Config.chef_server_url = 'http://localhost:8889'
+        Chef::Config.node_name = nil
+        Chef::Config.client_key = nil
+        api = Chef::ServerAPI.new
+        api.get('nodes/x')['name'].should == 'x'
+      rescue
+        if exception
+          raise exception
+        else
+          raise
+        end
+      ensure
+        t.kill
+      end
+    end
+  end
+end

data/spec/integration/knife/show_spec.rb

@@ -16,12 +16,15 @@
 # limitations under the License.
 
 require 'support/shared/integration/integration_helper'
+require 'support/shared/context/config'
 require 'chef/knife/show'
 
 describe 'knife show' do
   extend IntegrationSupport
   include KnifeSupport
 
+  include_context "default config options"
+
   when_the_chef_server "has one of each thing" do
     client 'x', '{}'
     cookbook 'x', '1.0.0', { 'metadata.rb' => 'version "1.0.0"' }

data/spec/support/pedant/run_pedant.rb

@@ -25,6 +25,7 @@ def start_server(chef_repo_path)
   Chef::Config.versioned_cookbooks = true
   chef_fs = Chef::ChefFS::Config.new.local_fs
   data_store = Chef::ChefFS::ChefFSDataStore.new(chef_fs)
+  data_store = ChefZero::DataStore::V1ToV2Adapter.new(data_store, 'chef', :org_defaults => ChefZero::DataStore::V1ToV2Adapter::ORG_DEFAULTS)
   server = ChefZero::Server.new(:port => 8889, :data_store => data_store)#, :log_level => :debug)
   server.start_background
   server

data/spec/support/platform_helpers.rb

@@ -27,18 +27,20 @@ def windows?
   !!(RUBY_PLATFORM =~ /mswin|mingw|windows/)
 end
 
-require 'ruby-wmi' if windows?
+require 'wmi-lite/wmi' if windows?
 
 def windows_domain_joined?
   return false unless windows?
-  WMI::Win32_ComputerSystem.find(:first).PartOfDomain
+  wmi = WmiLite::Wmi.new
+  computer_system = wmi.first_of('Win32_ComputerSystem')
+  computer_system['partofdomain']
 end
 
 def windows_win2k3?
   return false unless windows?
-
-  host = WMI::Win32_OperatingSystem.find(:first)
-  (host.version && host.version.start_with?("5.2"))
+  wmi = WmiLite::Wmi.new
+  host = wmi.first_of('Win32_OperatingSystem')
+  (host['version'] && host['version'].start_with?("5.2"))
 end
 
 def mac_osx_106?

data/spec/support/shared/context/config.rb

@@ -0,0 +1,21 @@
+
+#
+# Define config file setups for spec tests here.
+# https://www.relishapp.com/rspec/rspec-core/docs/example-groups/shared-context
+#
+
+# Required chef files here:
+require 'chef/config'
+
+# Required spec files here:
+require 'spec_helper'
+
+# Basic config. Nothing fancy.
+shared_context "default config options" do
+  before do
+    Chef::Config[:cache_path] = windows? ? 'C:\chef' : '/var/chef'
+  end
+
+  # Don't need to have an after block to reset the config...
+  # The spec_helper.rb takes care of resetting the config state.
+end

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

@@ -645,6 +645,58 @@ shared_examples_for "a configured file resource" do
     end
   end
 
+  context "when the target file does not exist" do
+    before(:each) do
+      FileUtils.rm_rf(path)
+    end
+
+    after(:each) do
+      FileUtils.rm_rf(path)
+    end
+
+    def symlink?(file_path)
+      if windows?
+        Chef::ReservedNames::Win32::File.symlink?(file_path)
+      else
+        File.symlink?(file_path)
+      end
+    end
+
+    def real_file?(file_path)
+      !symlink?(file_path) && File.file?(file_path)
+    end
+
+    describe "when force_unlink is set to true" do
+      it ":create updates the target" do
+        resource.force_unlink(true)
+        resource.run_action(:create)
+        real_file?(path).should be_true
+        binread(path).should == expected_content
+        resource.should be_updated_by_last_action
+      end
+    end
+
+    describe "when force_unlink is set to false" do
+      it ":create updates the target" do
+        resource.force_unlink(true)
+        resource.run_action(:create)
+        real_file?(path).should be_true
+        binread(path).should == expected_content
+        resource.should be_updated_by_last_action
+      end
+    end
+
+    describe "when force_unlink is not set (default)" do
+      it ":create updates the target" do
+        resource.force_unlink(true)
+        resource.run_action(:create)
+        real_file?(path).should be_true
+        binread(path).should == expected_content
+        resource.should be_updated_by_last_action
+      end
+    end
+  end
+
   context "when the target file is a directory" do
     before(:each) do
       FileUtils.mkdir_p(path)

data/spec/unit/chef_fs/parallelizer.rb

@@ -0,0 +1,482 @@
+require 'spec_helper'
+require 'chef/chef_fs/parallelizer'
+
+describe Chef::ChefFS::Parallelizer do
+  before :each do
+    @start_time = Time.now
+  end
+
+  def elapsed_time
+    Time.now - @start_time
+  end
+
+  after :each do
+    parallelizer.kill
+  end
+
+  context 'With a Parallelizer with 5 threads' do
+    let :parallelizer do
+      Chef::ChefFS::Parallelizer.new(5)
+    end
+
+    def parallelize(inputs, options = {}, &block)
+      parallelizer.parallelize(inputs, { :main_thread_processing => false }.merge(options), &block)
+    end
+
+    it "parallel_do creates unordered output as soon as it is available" do
+      outputs = []
+      parallelizer.parallel_do([0.5,0.3,0.1]) do |val|
+        sleep val
+        outputs << val
+      end
+      elapsed_time.should < 0.6
+      outputs.should == [ 0.1, 0.3, 0.5 ]
+    end
+
+    context "With :ordered => false (unordered output)" do
+      it "An empty input produces an empty output" do
+        parallelize([], :ordered => false) do
+          sleep 10
+        end.to_a == []
+        elapsed_time.should < 0.1
+      end
+
+      it "10 sleep(0.2)s complete within 0.5 seconds" do
+        parallelize(1.upto(10), :ordered => false) do |i|
+          sleep 0.2
+          'x'
+        end.to_a.should == %w(x x x x x x x x x x)
+        elapsed_time.should < 0.5
+      end
+
+      it "The output comes as soon as it is available" do
+        enum = parallelize([0.5,0.3,0.1], :ordered => false) do |val|
+          sleep val
+          val
+        end
+        enum.map do |value|
+          elapsed_time.should < value+0.1
+          value
+        end.should == [ 0.1, 0.3, 0.5 ]
+      end
+
+      it "An exception in input is passed through but does NOT stop processing" do
+        input = TestEnumerable.new(0.5,0.3,0.1) do
+          raise 'hi'
+        end
+        enum = parallelize(input, :ordered => false) { |x| sleep(x); x }
+        results = []
+        expect { enum.each { |value| results << value } }.to raise_error 'hi'
+        results.should == [ 0.1, 0.3, 0.5 ]
+        elapsed_time.should < 0.6
+      end
+
+      it "Exceptions in output are raised after all processing is done" do
+        processed = 0
+        enum = parallelize([1,2,'x',3], :ordered => false) do |x|
+          if x == 'x'
+            sleep 0.1
+            raise 'hi'
+          end
+          sleep 0.2
+          processed += 1
+          x
+        end
+        results = []
+        expect { enum.each { |value| results << value } }.to raise_error 'hi'
+        results.sort.should == [ 1, 2, 3 ]
+        elapsed_time.should < 0.3
+        processed.should == 3
+      end
+
+      it "Exceptions with :stop_on_exception are raised after all processing is done" do
+        processed = 0
+        parallelized = parallelize([0.3,0.3,'x',0.3,0.3,0.3,0.3,0.3], :ordered => false, :stop_on_exception => true) do |x|
+          if x == 'x'
+            sleep(0.1)
+            raise 'hi'
+          end
+          sleep(x)
+          processed += 1
+          x
+        end
+        expect { parallelized.to_a }.to raise_error 'hi'
+        processed.should == 4
+      end
+    end
+
+    context "With :ordered => true (ordered output)" do
+      it "An empty input produces an empty output" do
+        parallelize([]) do
+          sleep 10
+        end.to_a == []
+        elapsed_time.should < 0.1
+      end
+
+      it "10 sleep(0.2)s complete within 0.5 seconds" do
+        parallelize(1.upto(10), :ordered => true) do |i|
+          sleep 0.2
+          'x'
+        end.to_a.should == %w(x x x x x x x x x x)
+        elapsed_time.should < 0.5
+      end
+
+      it "Output comes in the order of the input" do
+        enum = parallelize([0.5,0.3,0.1]) do |val|
+          sleep val
+          val
+        end.enum_for(:each_with_index)
+        enum.next.should == [ 0.5, 0 ]
+        enum.next.should == [ 0.3, 1 ]
+        enum.next.should == [ 0.1, 2 ]
+        elapsed_time.should < 0.6
+      end
+
+      it "Exceptions in input are raised in the correct sequence but do NOT stop processing" do
+        input = TestEnumerable.new(0.5,0.3,0.1) do
+          raise 'hi'
+        end
+        results = []
+        enum = parallelize(input) { |x| sleep(x); x }
+        expect { enum.each { |value| results << value } }.to raise_error 'hi'
+        elapsed_time.should < 0.6
+        results.should == [ 0.5, 0.3, 0.1 ]
+      end
+
+      it "Exceptions in output are raised in the correct sequence and running processes do NOT stop processing" do
+        processed = 0
+        enum = parallelize([1,2,'x',3]) do |x|
+          if x == 'x'
+            sleep(0.1)
+            raise 'hi'
+          end
+          sleep(0.2)
+          processed += 1
+          x
+        end
+        results = []
+        expect { enum.each { |value| results << value } }.to raise_error 'hi'
+        results.should == [ 1, 2 ]
+        elapsed_time.should < 0.3
+        processed.should == 3
+      end
+
+      it "Exceptions with :stop_on_exception are raised after all processing is done" do
+        processed = 0
+        parallelized = parallelize([0.3,0.3,'x',0.3,0.3,0.3,0.3,0.3], :ordered => false, :stop_on_exception => true) do |x|
+          if x == 'x'
+            sleep(0.1)
+            raise 'hi'
+          end
+          sleep(x)
+          processed += 1
+          x
+        end
+        expect { parallelized.to_a }.to raise_error 'hi'
+        processed.should == 4
+      end
+    end
+
+    it "When the input is slow, output still proceeds" do
+      input = TestEnumerable.new do |&block|
+        block.call(1)
+        sleep 0.1
+        block.call(2)
+        sleep 0.1
+        block.call(3)
+        sleep 0.1
+      end
+      enum = parallelize(input) { |x| x }
+      enum.map do |value|
+        elapsed_time.should < (value+1)*0.1
+        value
+      end.should == [ 1, 2, 3 ]
+    end
+  end
+
+  context "With a Parallelizer with 1 thread" do
+    let :parallelizer do
+      Chef::ChefFS::Parallelizer.new(1)
+    end
+
+    context "when the thread is occupied with a job" do
+      before :each do
+        parallelizer
+        started = false
+        @occupying_job_finished = occupying_job_finished = [ false ]
+        @thread = Thread.new do
+          begin
+            parallelizer.parallelize([0], :main_thread_processing => false) do |x|
+              started = true
+              sleep(0.3)
+              occupying_job_finished[0] = true
+            end.wait
+          ensure
+          end
+        end
+        while !started
+          sleep(0.01)
+        end
+      end
+
+      after :each do
+        if RUBY_VERSION.to_f > 1.8
+          Thread.kill(@thread)
+        end
+      end
+
+      it "parallelize with :main_thread_processing = true does not block" do
+        parallelizer.parallelize([1]) do |x|
+          sleep(0.1)
+          x
+        end.to_a.should == [ 1 ]
+        elapsed_time.should < 0.2
+      end
+
+      it "parallelize with :main_thread_processing = false waits for the job to finish" do
+        parallelizer.parallelize([1], :main_thread_processing => false) do |x|
+          sleep(0.1)
+          x+1
+        end.to_a.should == [ 2 ]
+        elapsed_time.should > 0.3
+      end
+
+      it "resizing the Parallelizer to 0 waits for the job to stop" do
+        elapsed_time.should < 0.2
+        parallelizer.resize(0)
+        parallelizer.num_threads.should == 0
+        elapsed_time.should > 0.25
+        @occupying_job_finished.should == [ true ]
+      end
+
+      it "stopping the Parallelizer waits for the job to finish" do
+        elapsed_time.should < 0.2
+        parallelizer.stop
+        parallelizer.num_threads.should == 0
+        elapsed_time.should > 0.25
+        @occupying_job_finished.should == [ true ]
+      end
+
+      it "resizing the Parallelizer to 2 does not stop the job" do
+        elapsed_time.should < 0.2
+        parallelizer.resize(2)
+        parallelizer.num_threads.should == 2
+        elapsed_time.should < 0.2
+        sleep(0.3)
+        @occupying_job_finished.should == [ true ]
+      end
+    end
+
+    context "enumerable methods should run efficiently" do
+      it ".count does not process anything" do
+        outputs_processed = 0
+        input_mapper = TestEnumerable.new(1,2,3,4,5,6)
+        enum = parallelizer.parallelize(input_mapper) do |x|
+          outputs_processed += 1
+          sleep(0.05) # Just enough to yield and get other inputs in the queue
+          x
+        end
+        enum.count.should == 6
+        outputs_processed.should == 0
+        input_mapper.num_processed.should == 6
+      end
+
+      it ".count with arguments works normally" do
+        outputs_processed = 0
+        input_mapper = TestEnumerable.new(1,1,1,1,2,2,2,3,3,4)
+        enum = parallelizer.parallelize(input_mapper) do |x|
+          outputs_processed += 1
+          x
+        end
+        enum.count { |x| x > 1 }.should == 6
+        enum.count(2).should == 3
+        outputs_processed.should == 20
+        input_mapper.num_processed.should == 20
+      end
+
+      it ".first does not enumerate anything other than the first result(s)" do
+        outputs_processed = 0
+        input_mapper = TestEnumerable.new(1,2,3,4,5,6)
+        enum = parallelizer.parallelize(input_mapper) do |x|
+          outputs_processed += 1
+          sleep(0.05) # Just enough to yield and get other inputs in the queue
+          x
+        end
+        enum.first.should == 1
+        enum.first(2).should == [1,2]
+        outputs_processed.should == 3
+        input_mapper.num_processed.should == 3
+      end
+
+      it ".take does not enumerate anything other than the first result(s)" do
+        outputs_processed = 0
+        input_mapper = TestEnumerable.new(1,2,3,4,5,6)
+        enum = parallelizer.parallelize(input_mapper) do |x|
+          outputs_processed += 1
+          sleep(0.05) # Just enough to yield and get other inputs in the queue
+          x
+        end
+        enum.take(2).should == [1,2]
+        outputs_processed.should == 2
+        input_mapper.num_processed.should == 2
+      end
+
+      it ".drop does not process anything other than the last result(s)" do
+        outputs_processed = 0
+        input_mapper = TestEnumerable.new(1,2,3,4,5,6)
+        enum = parallelizer.parallelize(input_mapper) do |x|
+          outputs_processed += 1
+          sleep(0.05) # Just enough to yield and get other inputs in the queue
+          x
+        end
+        enum.drop(2).should == [3,4,5,6]
+        outputs_processed.should == 4
+        input_mapper.num_processed.should == 6
+      end
+
+      if Enumerable.method_defined?(:lazy)
+        it ".lazy.take does not enumerate anything other than the first result(s)" do
+          outputs_processed = 0
+          input_mapper = TestEnumerable.new(1,2,3,4,5,6)
+          enum = parallelizer.parallelize(input_mapper) do |x|
+            outputs_processed += 1
+            sleep(0.05) # Just enough to yield and get other inputs in the queue
+            x
+          end
+          enum.lazy.take(2).to_a.should == [1,2]
+          outputs_processed.should == 2
+          input_mapper.num_processed.should == 2
+        end
+
+        it ".drop does not process anything other than the last result(s)" do
+          outputs_processed = 0
+          input_mapper = TestEnumerable.new(1,2,3,4,5,6)
+          enum = parallelizer.parallelize(input_mapper) do |x|
+            outputs_processed += 1
+            sleep(0.05) # Just enough to yield and get other inputs in the queue
+            x
+          end
+          enum.lazy.drop(2).to_a.should == [3,4,5,6]
+          outputs_processed.should == 4
+          input_mapper.num_processed.should == 6
+        end
+
+        it "lazy enumerable is actually lazy" do
+          outputs_processed = 0
+          input_mapper = TestEnumerable.new(1,2,3,4,5,6)
+          enum = parallelizer.parallelize(input_mapper) do |x|
+            outputs_processed += 1
+            sleep(0.05) # Just enough to yield and get other inputs in the queue
+            x
+          end
+          enum.lazy.take(2)
+          enum.lazy.drop(2)
+          sleep(0.1)
+          outputs_processed.should == 0
+          input_mapper.num_processed.should == 0
+        end
+      end
+    end
+
+    context "running enumerable multiple times should function correctly" do
+      it ".map twice on the same parallel enumerable returns the correct results and re-processes the input" do
+        outputs_processed = 0
+        input_mapper = TestEnumerable.new(1,2,3)
+        enum = parallelizer.parallelize(input_mapper) do |x|
+          outputs_processed += 1
+          x
+        end
+        enum.map { |x| x }.should == [1,2,3]
+        enum.map { |x| x }.should == [1,2,3]
+        outputs_processed.should == 6
+        input_mapper.num_processed.should == 6
+      end
+
+      it ".first and then .map on the same parallel enumerable returns the correct results and re-processes the input" do
+        outputs_processed = 0
+        input_mapper = TestEnumerable.new(1,2,3)
+        enum = parallelizer.parallelize(input_mapper) do |x|
+          outputs_processed += 1
+          x
+        end
+        enum.first.should == 1
+        enum.map { |x| x }.should == [1,2,3]
+        outputs_processed.should >= 4
+        input_mapper.num_processed.should >= 4
+      end
+
+      it "two simultaneous enumerations throws an exception" do
+        enum = parallelizer.parallelize([1,2,3]) { |x| x }
+        a = enum.enum_for(:each)
+        a.next
+        expect do
+          b = enum.enum_for(:each)
+          b.next
+        end.to raise_error
+      end
+    end
+  end
+
+  context "With a Parallelizer with 0 threads" do
+    let :parallelizer do
+      Chef::ChefFS::Parallelizer.new(0)
+    end
+
+    context "And main_thread_processing on" do
+      it "succeeds in running" do
+        parallelizer.parallelize([0.5]) { |x| x*2 }.to_a.should == [1]
+      end
+    end
+  end
+
+  context "With a Parallelizer with 10 threads" do
+    let :parallelizer do
+      Chef::ChefFS::Parallelizer.new(10)
+    end
+
+    it "does not have contention issues with large numbers of inputs" do
+      parallelizer.parallelize(1.upto(500)) { |x| x+1 }.to_a.should == 2.upto(501).to_a
+    end
+
+    it "does not have contention issues with large numbers of inputs with ordering off" do
+      parallelizer.parallelize(1.upto(500), :ordered => false) { |x| x+1 }.to_a.sort.should == 2.upto(501).to_a
+    end
+
+    it "does not have contention issues with large numbers of jobs and inputs with ordering off" do
+      parallelizers = 0.upto(99).map do
+        parallelizer.parallelize(1.upto(500)) { |x| x+1 }
+      end
+      outputs = []
+      threads = 0.upto(99).map do |i|
+        Thread.new { outputs[i] = parallelizers[i].to_a }
+      end
+      threads.each { |thread| thread.join }
+      outputs.each { |output| output.sort.should == 2.upto(501).to_a }
+    end
+  end
+
+  class TestEnumerable
+    include Enumerable
+
+    def initialize(*values, &block)
+      @values = values
+      @block = block
+      @num_processed = 0
+    end
+
+    attr_reader :num_processed
+
+    def each(&each_block)
+      @values.each do |value|
+        @num_processed += 1
+        each_block.call(value)
+      end
+      if @block
+        @block.call do |value|
+          @num_processed += 1
+          each_block.call(value)
+        end
+      end
+    end
+  end
+end