chef 12.13.37-universal-mingw32 → 12.14.60-universal-mingw32

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

@@ -55,13 +55,13 @@ shared_examples_for "user or client create" do
     end
 
     context "when chef_key is returned by the server" do
-      let(:chef_key) {
+      let(:chef_key) do
         {
           "chef_key" => {
             "public_key" => "some_public_key",
           },
         }
-      }
+      end
 
       it "puts the public key into the objectr returned by create" do
         expect(rest_v1).to receive(:post).with(url, payload).and_return(payload.merge(chef_key))
@@ -70,14 +70,14 @@ shared_examples_for "user or client create" do
       end
 
       context "when private_key is returned in chef_key" do
-        let(:chef_key) {
+        let(:chef_key) do
           {
             "chef_key" => {
               "public_key" => "some_public_key",
               "private_key" => "some_private_key",
             },
           }
-        }
+        end
 
         it "puts the private key into the object returned by create" do
           expect(rest_v1).to receive(:post).with(url, payload).and_return(payload.merge(chef_key))

data/spec/tiny_server.rb

@@ -20,97 +20,82 @@ require "rubygems"
 require "webrick"
 require "webrick/https"
 require "rack"
-#require 'thin'
+require "thread"
 require "singleton"
 require "open-uri"
 require "chef/config"
 
 module TinyServer
 
-  class Server < Rack::Server
-
-    attr_writer :app
-
-    def self.setup(options = nil, &block)
-      tiny_app = new(options)
-      app_code = Rack::Builder.new(&block).to_app
-      tiny_app.app = app_code
-      tiny_app
-    end
-
-    def shutdown
-      server.shutdown
-    end
-  end
-
   class Manager
 
     # 5 == debug, 3 == warning
     LOGGER = WEBrick::Log.new(STDOUT, 3)
     DEFAULT_OPTIONS = {
-      :server => "webrick",
-      :Port => 9000,
-      :Host => "localhost",
-      :environment => :none,
-      :Logger => LOGGER,
-      :AccessLog => [] # Remove this option to enable the access log when debugging.
+      Port: 9000,
+      Host: "localhost",
+      Logger: LOGGER,
+      # SSLEnable: options[:ssl],
+      # SSLCertName: [ [ 'CN', WEBrick::Utils::getservername ] ],
+      AccessLog: [], # Remove this option to enable the access log when debugging.
     }
 
-    def initialize(options = nil)
-      @options = options ? DEFAULT_OPTIONS.merge(options) : DEFAULT_OPTIONS
+    def initialize(**options)
+      @options = DEFAULT_OPTIONS.merge(options)
       @creator = caller.first
     end
 
-    def start
+    attr_reader :options
+    attr_reader :creator
+    attr_reader :server
+
+    def start(timeout = 5)
+      raise "Server already started!" if server
+
+      # Create the server (but don't start yet)
+      start_queue = Queue.new
+      @server = create_server(StartCallback: proc { start_queue << true })
+
       @server_thread = Thread.new do
-        @server = Server.setup(@options) do
-          run API.instance
-        end
-        @old_handler = trap(:INT, "EXIT")
-        @server.start
+        # Ensure any exceptions will cause the main rspec thread to fail too
+        Thread.current.abort_on_exception = true
+        server.start
       end
-      block_until_started
-      trap(:INT, @old_handler)
-    end
 
-    def url
-      "http://localhost:#{@options[:Port]}"
+      # Wait for the StartCallback to tell us we've started
+      Timeout.timeout(timeout) do
+        start_queue.pop
+      end
     end
 
-    def block_until_started
-      200.times do
-        if started? && !@server.nil?
-          return true
+    def stop(timeout = 5)
+      if server
+        server.shutdown
+        @server = nil
+      end
+
+      if server_thread
+        begin
+          # Wait for a normal shutdown
+          server_thread.join(timeout)
+        rescue
+          # If it wouldn't shut down normally, kill it.
+          server_thread.kill
+          server_thread.join(timeout)
         end
+        @server_thread = nil
       end
-      raise "ivar weirdness" if started? && @server.nil?
-      raise "TinyServer failed to boot :/"
-    end
-
-    def started?
-      open(url)
-      true
-    rescue OpenURI::HTTPError
-      true
-    rescue Errno::ECONNREFUSED, EOFError, Errno::ECONNRESET => e
-      sleep 0.1
-      true
-      # If the host has ":::1 localhost" in its hosts file and if IPv6
-      # is not enabled we can get NetworkUnreachable exception...
-    rescue Errno::ENETUNREACH, Net::ReadTimeout, IO::EAGAINWaitReadable,
-        Errno::EHOSTUNREACH => e
-      sleep 0.1
-      false
-    end
-
-    def stop
-      # yes, this is terrible.
-      @server.shutdown
-      @server_thread.kill
-      @server_thread.join
-      @server_thread = nil
     end
 
+    private
+
+    attr_reader :server_thread
+
+    def create_server(**extra_options)
+      server = WEBrick::HTTPServer.new(**options, **extra_options)
+      server.mount("/", Rack::Handler::WEBrick, API.instance)
+      server
+    end
   end
 
   class API

data/spec/unit/api_client_v1_spec.rb

@@ -326,13 +326,13 @@ describe Chef::ApiClientV1 do
   describe "Versioned API Interactions" do
     let(:response_406) { OpenStruct.new(:code => "406") }
     let(:exception_406) { Net::HTTPServerException.new("406 Not Acceptable", response_406) }
-    let(:payload) {
+    let(:payload) do
       {
         :name => "some_name",
         :validator => true,
         :admin => true,
       }
-    }
+    end
 
     before do
       @client = Chef::ApiClientV1.new

data/spec/unit/application_spec.rb

@@ -361,7 +361,7 @@ describe Chef::Application do
         end
       end
 
-      context 'when called with an Array-like argument (#size)' do
+      context "when called with an Array-like argument (#size)" do
         before do
           allow(app).to receive(:fork_chef_client).and_return(true)
           allow(app).to receive(:run_with_graceful_exit_option).and_return(true)

data/spec/unit/audit/audit_event_proxy_spec.rb

@@ -34,8 +34,9 @@ describe Chef::Audit::AuditEventProxy do
   describe "#example_group_started" do
 
     let(:description) { "poots" }
-    let(:group) { double("ExampleGroup", :parent_groups => parents,
-                                         :description => description) }
+    let(:group) do
+      double("ExampleGroup", :parent_groups => parents,
+                             :description => description) end
     let(:notification) { double("Notification", :group => group) }
 
     context "when notified from a top-level example group" do
@@ -120,35 +121,36 @@ describe Chef::Audit::AuditEventProxy do
 
       let(:examples) { [example] }
 
-      let(:example) { double("Example", :metadata => metadata,
-                                        :description => example_description,
-                                        :full_description => full_description, :exception => nil) }
+      let(:example) do
+        double("Example", :metadata => metadata,
+                          :description => example_description,
+                          :full_description => full_description, :exception => nil) end
 
-      let(:metadata) {
+      let(:metadata) do
         {
           :described_class => described_class,
           :example_group => example_group,
           :line_number => line,
         }
-      }
+      end
 
-      let(:example_group) {
+      let(:example_group) do
         {
           :description => group_description,
           :parent_example_group => parent_group,
         }
-      }
+      end
 
-      let(:parent_group) {
+      let(:parent_group) do
         {
           :description => control_group_name,
           :parent_example_group => nil,
         }
-      }
+      end
 
       let(:line) { 27 }
 
-      let(:control_data) {
+      let(:control_data) do
         {
           :name => example_description,
           :desc => full_description,
@@ -157,7 +159,7 @@ describe Chef::Audit::AuditEventProxy do
           :context => context,
           :line_number => line,
         }
-      }
+      end
 
       shared_examples "built control" do
 
@@ -218,12 +220,14 @@ describe Chef::Audit::AuditEventProxy do
         let(:control_group_name) { "application ports" }
         let(:group_description) { "#{resource_type} #{resource_name}" }
         let(:example_description) { "should not be listening" }
-        let(:full_description) { [control_group_name, group_description,
-          example_description].join(" ") }
+        let(:full_description) do
+          [control_group_name, group_description,
+          example_description].join(" ") end
 
         # Metadata fields
-        let(:described_class) { double("Serverspec::Type::Port",
-          :class => "Serverspec::Type::Port", :name => resource_name) }
+        let(:described_class) do
+          double("Serverspec::Type::Port",
+          :class => "Serverspec::Type::Port", :name => resource_name) end
 
         # Control data fields
         let(:resource_type) { "Port" }
@@ -246,8 +250,9 @@ describe Chef::Audit::AuditEventProxy do
         let(:control_group_name) { "application ports" }
         let(:group_description) { "port 111" }
         let(:example_description) { "is not listening" }
-        let(:full_description) { [control_group_name, group_description,
-          example_description].join(" ") }
+        let(:full_description) do
+          [control_group_name, group_description,
+          example_description].join(" ") end
 
         # Metadata fields
         let(:described_class) { nil }
@@ -276,27 +281,29 @@ describe Chef::Audit::AuditEventProxy do
         let(:outer_group_description) { "File \"tmp/audit\"" }
         let(:group_description) { "#{resource_type} #{resource_name}" }
         let(:example_description) { "is a file" }
-        let(:full_description) { [control_group_name, outer_group_description,
-          group_description, example_description].join(" ") }
+        let(:full_description) do
+          [control_group_name, outer_group_description,
+          group_description, example_description].join(" ") end
 
         # Metadata parts
-        let(:described_class) { double("Serverspec::Type::File",
-          :class => "Serverspec::Type::File", :name => resource_name) }
+        let(:described_class) do
+          double("Serverspec::Type::File",
+          :class => "Serverspec::Type::File", :name => resource_name) end
 
         # Example group parts
-        let(:parent_group) {
+        let(:parent_group) do
           {
             :description => outer_group_description,
             :parent_example_group => control_group,
           }
-        }
+        end
 
-        let(:control_group) {
+        let(:control_group) do
           {
             :description => control_group_name,
             :parent_example_group => nil,
           }
-        }
+        end
 
         # Control data parts
         let(:resource_type) { "File" }

data/spec/unit/audit/audit_reporter_spec.rb

@@ -28,8 +28,9 @@ describe Chef::Audit::AuditReporter do
   let(:run_id) { 0 }
   let(:start_time) { Time.new(2014, 12, 3, 9, 31, 05, "-08:00") }
   let(:end_time) { Time.new(2014, 12, 3, 9, 36, 14, "-08:00") }
-  let(:run_status) { instance_double(Chef::RunStatus, :node => node, :run_id => run_id,
-                                                      :start_time => start_time, :end_time => end_time) }
+  let(:run_status) do
+    instance_double(Chef::RunStatus, :node => node, :run_id => run_id,
+                                     :start_time => start_time, :end_time => end_time) end
 
   describe "#audit_phase_start" do
 
@@ -85,9 +86,10 @@ describe Chef::Audit::AuditReporter do
 
       context "when audit phase failed" do
 
-        let(:audit_error) { double("AuditError", :class => "Chef::Exceptions::AuditError",
-                                                 :message => "Audit phase failed with error message: derpderpderp",
-                                                 :backtrace => ["/path/recipe.rb:57", "/path/library.rb:106"]) }
+        let(:audit_error) do
+          double("AuditError", :class => "Chef::Exceptions::AuditError",
+                               :message => "Audit phase failed with error message: derpderpderp",
+                               :backtrace => ["/path/recipe.rb:57", "/path/library.rb:106"]) end
 
         before do
           reporter.instance_variable_set(:@audit_phase_error, audit_error)
@@ -233,13 +235,15 @@ EOM
     let(:audit_data) { Chef::Audit::AuditData.new(node.name, run_id) }
     let(:run_data) { audit_data.to_hash }
 
-    let(:audit_error) { double("AuditError", :class => "Chef::Exceptions::AuditError",
-                                             :message => "Audit phase failed with error message: derpderpderp",
-                                             :backtrace => ["/path/recipe.rb:57", "/path/library.rb:106"]) }
+    let(:audit_error) do
+      double("AuditError", :class => "Chef::Exceptions::AuditError",
+                           :message => "Audit phase failed with error message: derpderpderp",
+                           :backtrace => ["/path/recipe.rb:57", "/path/library.rb:106"]) end
 
-    let(:run_error) { double("RunError", :class => "Chef::Exceptions::RunError",
-                                         :message => "This error shouldn't be reported.",
-                                         :backtrace => ["fix it", "fix it", "fix it"]) }
+    let(:run_error) do
+      double("RunError", :class => "Chef::Exceptions::RunError",
+                         :message => "This error shouldn't be reported.",
+                         :backtrace => ["fix it", "fix it", "fix it"]) end
 
     before do
       allow(reporter).to receive(:auditing_enabled?).and_return(true)
@@ -276,23 +280,27 @@ EOM
 
   shared_context "audit data" do
 
-    let(:control_group_foo) { instance_double(Chef::Audit::ControlGroupData,
-      :metadata => double("foo metadata")) }
-    let(:control_group_bar) { instance_double(Chef::Audit::ControlGroupData,
-      :metadata => double("bar metadata")) }
+    let(:control_group_foo) do
+      instance_double(Chef::Audit::ControlGroupData,
+      :metadata => double("foo metadata")) end
+    let(:control_group_bar) do
+      instance_double(Chef::Audit::ControlGroupData,
+      :metadata => double("bar metadata")) end
 
-    let(:ordered_control_groups) {
+    let(:ordered_control_groups) do
       {
         "foo" => control_group_foo,
         "bar" => control_group_bar,
       }
-    }
+    end
 
-    let(:audit_data) { instance_double(Chef::Audit::AuditData,
-      :add_control_group => true) }
+    let(:audit_data) do
+      instance_double(Chef::Audit::AuditData,
+      :add_control_group => true) end
 
-    let(:run_context) { instance_double(Chef::RunContext,
-      :audits => ordered_control_groups) }
+    let(:run_context) do
+      instance_double(Chef::RunContext,
+      :audits => ordered_control_groups) end
 
     before do
       allow(reporter).to receive(:ordered_control_groups).and_return(ordered_control_groups)
@@ -340,8 +348,9 @@ EOM
     include_context "audit data"
 
     let(:name) { "bat" }
-    let(:control_group) { instance_double(Chef::Audit::ControlGroupData,
-      :metadata => double("metadata")) }
+    let(:control_group) do
+      instance_double(Chef::Audit::ControlGroupData,
+      :metadata => double("metadata")) end
 
     before do
       allow(Chef::Audit::ControlGroupData).to receive(:new).

data/spec/unit/audit/control_group_data_spec.rb

@@ -122,9 +122,10 @@ describe Chef::Audit::ControlData do
   let(:context) { nil }
   let(:line_number) { 27 }
 
-  let(:control_data) { described_class.new(name: name,
-                                           resource_type: resource_type, resource_name: resource_name,
-                                           context: context, line_number: line_number) }
+  let(:control_data) do
+    described_class.new(name: name,
+                        resource_type: resource_type, resource_name: resource_name,
+                        context: context, line_number: line_number) end
 
   describe "#to_hash" do
 
@@ -171,7 +172,7 @@ describe Chef::Audit::ControlGroupData do
     let(:context) { nil }
     let(:line_number) { 0 }
 
-    let(:control_data) {
+    let(:control_data) do
       {
         :name => name,
         :resource_type => resource_type,
@@ -179,16 +180,17 @@ describe Chef::Audit::ControlGroupData do
         :context => context,
         :line_number => line_number,
       }
-    }
+    end
 
   end
 
   shared_context "control" do
     include_context "control data"
 
-    let(:control) { Chef::Audit::ControlData.new(name: name,
-                                                 resource_type: resource_type, resource_name: resource_name,
-                                                 context: context, line_number: line_number) }
+    let(:control) do
+      Chef::Audit::ControlData.new(name: name,
+                                   resource_type: resource_type, resource_name: resource_name,
+                                   context: context, line_number: line_number) end
 
     before do
       allow(Chef::Audit::ControlData).to receive(:new).
@@ -436,15 +438,18 @@ describe Chef::Audit::ControlGroupData do
         let(:control_hash_2) { { :line_number => 13 } }
         let(:control_hash_3) { { :line_number => 35 } }
 
-        let(:control_1) { double("control 1",
+        let(:control_1) do
+          double("control 1",
           :line_number => control_hash_1[:line_number],
-          :to_hash => control_hash_1) }
-        let(:control_2) { double("control 2",
+          :to_hash => control_hash_1) end
+        let(:control_2) do
+          double("control 2",
           :line_number => control_hash_2[:line_number],
-          :to_hash => control_hash_2) }
-        let(:control_3) { double("control 3",
+          :to_hash => control_hash_2) end
+        let(:control_3) do
+          double("control 3",
           :line_number => control_hash_3[:line_number],
-          :to_hash => control_hash_3) }
+          :to_hash => control_hash_3) end
 
         let(:control_list) { [control_1, control_2, control_3] }
         let(:ordered_control_hashes) { [control_hash_2, control_hash_1, control_hash_3] }