chef 12.6.0 → 12.7.2

data/spec/unit/chef_fs/file_system/cookbook_subdir_spec.rb

@@ -1,6 +1,6 @@
 #
-# Author:: John Keiser (<jkeiser@opscode.com>)
-# Copyright:: Copyright (c) 2012 Opscode, Inc.
+# Author:: John Keiser (<jkeiser@chef.io>)
+# Copyright:: Copyright 2012-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,19 +16,19 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
-require 'chef/chef_fs/file_system/cookbook_subdir'
+require "spec_helper"
+require "chef/chef_fs/file_system/chef_server/cookbook_subdir"
 
-describe Chef::ChefFS::FileSystem::CookbookSubdir do
+describe Chef::ChefFS::FileSystem::ChefServer::CookbookSubdir do
   let(:root) do
-    Chef::ChefFS::FileSystem::BaseFSDir.new('', nil)
+    Chef::ChefFS::FileSystem::BaseFSDir.new("", nil)
   end
 
   let(:cookbook_subdir) do
-    Chef::ChefFS::FileSystem::CookbookSubdir.new('test', root, false, true)
+    Chef::ChefFS::FileSystem::ChefServer::CookbookSubdir.new("test", root, false, true)
   end
 
-  it 'can get child' do
-    cookbook_subdir.child('test')
+  it "can get child" do
+    cookbook_subdir.child("test")
   end
 end

data/spec/unit/chef_fs/file_system/operation_failed_error_spec.rb

@@ -1,6 +1,6 @@
 #
-# Author:: John Keiser (<jkeiser@opscode.com>)
-# Copyright:: Copyright (c) 2012 Opscode, Inc.
+# Author:: John Keiser (<jkeiser@chef.io>)
+# Copyright:: Copyright 2012-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,15 +16,15 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
-require 'chef/chef_fs/file_system/operation_failed_error'
+require "spec_helper"
+require "chef/chef_fs/file_system/operation_failed_error"
 
 describe Chef::ChefFS::FileSystem::OperationFailedError do
-  context 'message' do
+  context "message" do
     let(:error_message) { 'HTTP error writing: 400 "Bad Request"' }
 
-    context 'has a cause attribute and HTTP result code is 400' do
-      it 'include error cause' do
+    context "has a cause attribute and HTTP result code is 400" do
+      it "include error cause" do
         allow_message_expectations_on_nil
         response_body = '{"error":["Invalid key test in request body"]}'
         allow(@response).to receive(:code).and_return("400")
@@ -36,8 +36,8 @@ describe Chef::ChefFS::FileSystem::OperationFailedError do
       end
     end
 
-    context 'does not have a cause attribute' do
-      it 'does not include error cause' do
+    context "does not have a cause attribute" do
+      it "does not include error cause" do
         expect {
           raise Chef::ChefFS::FileSystem::OperationFailedError.new(:write, self), error_message
         }.to raise_error(Chef::ChefFS::FileSystem::OperationFailedError, error_message)

data/spec/unit/chef_fs/file_system_spec.rb

@@ -1,6 +1,6 @@
 #
-# Author:: John Keiser (<jkeiser@opscode.com>)
-# Copyright:: Copyright (c) 2012 Opscode, Inc.
+# Author:: John Keiser (<jkeiser@chef.io>)
+# Copyright:: Copyright 2012-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,132 +16,132 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
-require 'chef/chef_fs/file_system'
-require 'chef/chef_fs/file_pattern'
+require "spec_helper"
+require "chef/chef_fs/file_system"
+require "chef/chef_fs/file_pattern"
 
 describe Chef::ChefFS::FileSystem do
   include FileSystemSupport
 
-  context 'with empty filesystem' do
-    let(:fs) { memory_fs('', {}) }
+  context "with empty filesystem" do
+    let(:fs) { memory_fs("", {}) }
 
-    context 'list' do
-      it '/' do
-        list_should_yield_paths(fs, '/', '/')
+    context "list" do
+      it "/" do
+        list_should_yield_paths(fs, "/", "/")
       end
-      it '/a' do
-        list_should_yield_paths(fs, '/a', '/a')
+      it "/a" do
+        list_should_yield_paths(fs, "/a", "/a")
       end
-      it '/a/b' do
-        list_should_yield_paths(fs, '/a/b', '/a/b')
+      it "/a/b" do
+        list_should_yield_paths(fs, "/a/b", "/a/b")
       end
-      it '/*' do
-        list_should_yield_paths(fs, '/*', '/')
+      it "/*" do
+        list_should_yield_paths(fs, "/*", "/")
       end
     end
 
-    context 'resolve_path' do
-      it '/' do
-        expect(Chef::ChefFS::FileSystem.resolve_path(fs, '/').path).to eq('/')
+    context "resolve_path" do
+      it "/" do
+        expect(Chef::ChefFS::FileSystem.resolve_path(fs, "/").path).to eq("/")
       end
-      it 'nonexistent /a' do
-        expect(Chef::ChefFS::FileSystem.resolve_path(fs, '/a').path).to eq('/a')
+      it "nonexistent /a" do
+        expect(Chef::ChefFS::FileSystem.resolve_path(fs, "/a").path).to eq("/a")
       end
-      it 'nonexistent /a/b' do
-        expect(Chef::ChefFS::FileSystem.resolve_path(fs, '/a/b').path).to eq('/a/b')
+      it "nonexistent /a/b" do
+        expect(Chef::ChefFS::FileSystem.resolve_path(fs, "/a/b").path).to eq("/a/b")
       end
     end
   end
 
-  context 'with a populated filesystem' do
+  context "with a populated filesystem" do
     let(:fs) {
-      memory_fs('', {
+      memory_fs("", {
         :a => {
           :aa => {
-            :c => '',
-            :zz => ''
+            :c => "",
+            :zz => "",
           },
           :ab => {
-            :c => '',
-          }
+            :c => ""
+          },
         },
-        :x => '',
-        :y => {}
-      })
+        :x => "",
+        :y => {},
+      },)
     }
-    context 'list' do
-      it '/**' do
-        list_should_yield_paths(fs, '/**', '/', '/a', '/x', '/y', '/a/aa', '/a/aa/c', '/a/aa/zz', '/a/ab', '/a/ab/c')
+    context "list" do
+      it "/**" do
+        list_should_yield_paths(fs, "/**", "/", "/a", "/x", "/y", "/a/aa", "/a/aa/c", "/a/aa/zz", "/a/ab", "/a/ab/c")
       end
-      it '/' do
-        list_should_yield_paths(fs, '/', '/')
+      it "/" do
+        list_should_yield_paths(fs, "/", "/")
       end
-      it '/*' do
-        list_should_yield_paths(fs, '/*', '/', '/a', '/x', '/y')
+      it "/*" do
+        list_should_yield_paths(fs, "/*", "/", "/a", "/x", "/y")
       end
-      it '/*/*' do
-        list_should_yield_paths(fs, '/*/*', '/a/aa', '/a/ab')
+      it "/*/*" do
+        list_should_yield_paths(fs, "/*/*", "/a/aa", "/a/ab")
       end
-      it '/*/*/*' do
-        list_should_yield_paths(fs, '/*/*/*', '/a/aa/c', '/a/aa/zz', '/a/ab/c')
+      it "/*/*/*" do
+        list_should_yield_paths(fs, "/*/*/*", "/a/aa/c", "/a/aa/zz", "/a/ab/c")
       end
-      it '/*/*/?' do
-        list_should_yield_paths(fs, '/*/*/?', '/a/aa/c', '/a/ab/c')
+      it "/*/*/?" do
+        list_should_yield_paths(fs, "/*/*/?", "/a/aa/c", "/a/ab/c")
       end
-      it '/a/*/c' do
-        list_should_yield_paths(fs, '/a/*/c', '/a/aa/c', '/a/ab/c')
+      it "/a/*/c" do
+        list_should_yield_paths(fs, "/a/*/c", "/a/aa/c", "/a/ab/c")
       end
-      it '/**b/c' do
-        list_should_yield_paths(fs, '/**b/c', '/a/ab/c')
+      it "/**b/c" do
+        list_should_yield_paths(fs, "/**b/c", "/a/ab/c")
       end
-      it '/a/ab/c' do
+      it "/a/ab/c" do
         no_blocking_calls_allowed
-        list_should_yield_paths(fs, '/a/ab/c', '/a/ab/c')
+        list_should_yield_paths(fs, "/a/ab/c", "/a/ab/c")
       end
-      it 'nonexistent /a/ab/blah' do
+      it "nonexistent /a/ab/blah" do
         no_blocking_calls_allowed
-        list_should_yield_paths(fs, '/a/ab/blah', '/a/ab/blah')
+        list_should_yield_paths(fs, "/a/ab/blah", "/a/ab/blah")
       end
-      it 'nonexistent /a/ab/blah/bjork' do
+      it "nonexistent /a/ab/blah/bjork" do
         no_blocking_calls_allowed
-        list_should_yield_paths(fs, '/a/ab/blah/bjork', '/a/ab/blah/bjork')
+        list_should_yield_paths(fs, "/a/ab/blah/bjork", "/a/ab/blah/bjork")
       end
     end
 
-    context 'resolve_path' do
+    context "resolve_path" do
       before(:each) do
         no_blocking_calls_allowed
       end
-      it 'resolves /' do
-        expect(Chef::ChefFS::FileSystem.resolve_path(fs, '/').path).to eq('/')
+      it "resolves /" do
+        expect(Chef::ChefFS::FileSystem.resolve_path(fs, "/").path).to eq("/")
       end
-      it 'resolves /x' do
-        expect(Chef::ChefFS::FileSystem.resolve_path(fs, '/x').path).to eq('/x')
+      it "resolves /x" do
+        expect(Chef::ChefFS::FileSystem.resolve_path(fs, "/x").path).to eq("/x")
       end
-      it 'resolves /a' do
-        expect(Chef::ChefFS::FileSystem.resolve_path(fs, '/a').path).to eq('/a')
+      it "resolves /a" do
+        expect(Chef::ChefFS::FileSystem.resolve_path(fs, "/a").path).to eq("/a")
       end
-      it 'resolves /a/aa' do
-        expect(Chef::ChefFS::FileSystem.resolve_path(fs, '/a/aa').path).to eq('/a/aa')
+      it "resolves /a/aa" do
+        expect(Chef::ChefFS::FileSystem.resolve_path(fs, "/a/aa").path).to eq("/a/aa")
       end
-      it 'resolves /a/aa/zz' do
-        expect(Chef::ChefFS::FileSystem.resolve_path(fs, '/a/aa/zz').path).to eq('/a/aa/zz')
+      it "resolves /a/aa/zz" do
+        expect(Chef::ChefFS::FileSystem.resolve_path(fs, "/a/aa/zz").path).to eq("/a/aa/zz")
       end
-      it 'resolves nonexistent /q/x/w' do
-        expect(Chef::ChefFS::FileSystem.resolve_path(fs, '/q/x/w').path).to eq('/q/x/w')
+      it "resolves nonexistent /q/x/w" do
+        expect(Chef::ChefFS::FileSystem.resolve_path(fs, "/q/x/w").path).to eq("/q/x/w")
       end
     end
 
-    context 'empty?' do
-      it 'is not empty /' do
-        expect(Chef::ChefFS::FileSystem.resolve_path(fs, '/').empty?).to be false
+    context "empty?" do
+      it "is not empty /" do
+        expect(Chef::ChefFS::FileSystem.resolve_path(fs, "/").empty?).to be false
       end
-      it 'is empty /y' do
-        expect(Chef::ChefFS::FileSystem.resolve_path(fs, '/y').empty?).to be true
+      it "is empty /y" do
+        expect(Chef::ChefFS::FileSystem.resolve_path(fs, "/y").empty?).to be true
       end
       it 'is not a directory and can\'t be tested /x' do
-        expect { Chef::ChefFS::FileSystem.resolve_path(fs, '/x').empty? }.to raise_error(NoMethodError)
+        expect { Chef::ChefFS::FileSystem.resolve_path(fs, "/x").empty? }.to raise_error(NoMethodError)
       end
     end
   end

data/spec/unit/chef_fs/parallelizer.rb

@@ -1,5 +1,5 @@
-require 'spec_helper'
-require 'chef/chef_fs/parallelizer'
+require "spec_helper"
+require "chef/chef_fs/parallelizer"
 
 describe Chef::ChefFS::Parallelizer do
   before :each do
@@ -14,7 +14,7 @@ describe Chef::ChefFS::Parallelizer do
     parallelizer.kill
   end
 
-  context 'With a Parallelizer with 5 threads' do
+  context "With a Parallelizer with 5 threads" do
     let :parallelizer do
       Chef::ChefFS::Parallelizer.new(5)
     end
@@ -25,7 +25,7 @@ describe Chef::ChefFS::Parallelizer do
 
     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|
+      parallelizer.parallel_do([0.5, 0.3, 0.1]) do |val|
         sleep val
         outputs << val
       end
@@ -44,46 +44,46 @@ describe Chef::ChefFS::Parallelizer do
       it "10 sleep(0.2)s complete within 0.5 seconds" do
         expect(parallelize(1.upto(10), :ordered => false) do |i|
           sleep 0.2
-          'x'
-        end.to_a).to eq(%w(x x x x x x x x x x))
+          "x"
+        end.to_a).to eq(%w{x x x x x x x x x x})
         expect(elapsed_time).to be < 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|
+        enum = parallelize([0.5, 0.3, 0.1], :ordered => false) do |val|
           sleep val
           val
         end
         expect(enum.map do |value|
-          expect(elapsed_time).to be < value+0.1
+          expect(elapsed_time).to be < value + 0.1
           value
         end).to eq([ 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'
+        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'
+        expect { enum.each { |value| results << value } }.to raise_error "hi"
         expect(results).to eq([ 0.1, 0.3, 0.5 ])
         expect(elapsed_time).to be < 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'
+        enum = parallelize([1, 2, "x", 3], :ordered => false) do |x|
+          if x == "x"
             sleep 0.1
-            raise 'hi'
+            raise "hi"
           end
           sleep 0.2
           processed += 1
           x
         end
         results = []
-        expect { enum.each { |value| results << value } }.to raise_error 'hi'
+        expect { enum.each { |value| results << value } }.to raise_error "hi"
         expect(results.sort).to eq([ 1, 2, 3 ])
         expect(elapsed_time).to be < 0.3
         expect(processed).to eq(3)
@@ -91,16 +91,16 @@ describe Chef::ChefFS::Parallelizer do
 
       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'
+        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'
+            raise "hi"
           end
           sleep(x)
           processed += 1
           x
         end
-        expect { parallelized.to_a }.to raise_error 'hi'
+        expect { parallelized.to_a }.to raise_error "hi"
         expect(processed).to eq(4)
       end
     end
@@ -116,13 +116,13 @@ describe Chef::ChefFS::Parallelizer do
       it "10 sleep(0.2)s complete within 0.5 seconds" do
         expect(parallelize(1.upto(10), :ordered => true) do |i|
           sleep 0.2
-          'x'
-        end.to_a).to eq(%w(x x x x x x x x x x))
+          "x"
+        end.to_a).to eq(%w{x x x x x x x x x x})
         expect(elapsed_time).to be < 0.5
       end
 
       it "Output comes in the order of the input" do
-        enum = parallelize([0.5,0.3,0.1]) do |val|
+        enum = parallelize([0.5, 0.3, 0.1]) do |val|
           sleep val
           val
         end.enum_for(:each_with_index)
@@ -133,29 +133,29 @@ describe Chef::ChefFS::Parallelizer do
       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'
+        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'
+        expect { enum.each { |value| results << value } }.to raise_error "hi"
         expect(elapsed_time).to be < 0.6
         expect(results).to eq([ 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'
+        enum = parallelize([1, 2, "x", 3]) do |x|
+          if x == "x"
             sleep(0.1)
-            raise 'hi'
+            raise "hi"
           end
           sleep(0.2)
           processed += 1
           x
         end
         results = []
-        expect { enum.each { |value| results << value } }.to raise_error 'hi'
+        expect { enum.each { |value| results << value } }.to raise_error "hi"
         expect(results).to eq([ 1, 2 ])
         expect(elapsed_time).to be < 0.3
         expect(processed).to eq(3)
@@ -163,16 +163,16 @@ describe Chef::ChefFS::Parallelizer do
 
       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'
+        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'
+            raise "hi"
           end
           sleep(x)
           processed += 1
           x
         end
-        expect { parallelized.to_a }.to raise_error 'hi'
+        expect { parallelized.to_a }.to raise_error "hi"
         expect(processed).to eq(4)
       end
     end
@@ -188,7 +188,7 @@ describe Chef::ChefFS::Parallelizer do
       end
       enum = parallelize(input) { |x| x }
       expect(enum.map do |value|
-        expect(elapsed_time).to be < (value+1)*0.1
+        expect(elapsed_time).to be < (value + 1) * 0.1
         value
       end).to eq([ 1, 2, 3 ])
     end
@@ -205,14 +205,11 @@ describe Chef::ChefFS::Parallelizer do
         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
+          parallelizer.parallelize([0], :main_thread_processing => false) do |x|
+            started = true
+            sleep(0.3)
+            occupying_job_finished[0] = true
+          end.wait
         end
         while !started
           sleep(0.01)
@@ -236,7 +233,7 @@ describe Chef::ChefFS::Parallelizer do
       it "parallelize with :main_thread_processing = false waits for the job to finish" do
         expect(parallelizer.parallelize([1], :main_thread_processing => false) do |x|
           sleep(0.1)
-          x+1
+          x + 1
         end.to_a).to eq([ 2 ])
         expect(elapsed_time).to be > 0.3
       end
@@ -270,7 +267,7 @@ describe Chef::ChefFS::Parallelizer do
     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)
+        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
@@ -283,7 +280,7 @@ describe Chef::ChefFS::Parallelizer do
 
       it ".count with arguments works normally" do
         outputs_processed = 0
-        input_mapper = TestEnumerable.new(1,1,1,1,2,2,2,3,3,4)
+        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
@@ -296,40 +293,40 @@ describe Chef::ChefFS::Parallelizer do
 
       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)
+        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
         expect(enum.first).to eq(1)
-        expect(enum.first(2)).to eq([1,2])
+        expect(enum.first(2)).to eq([1, 2])
         expect(outputs_processed).to eq(3)
         expect(input_mapper.num_processed).to eq(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)
+        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
-        expect(enum.take(2)).to eq([1,2])
+        expect(enum.take(2)).to eq([1, 2])
         expect(outputs_processed).to eq(2)
         expect(input_mapper.num_processed).to eq(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)
+        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
-        expect(enum.drop(2)).to eq([3,4,5,6])
+        expect(enum.drop(2)).to eq([3, 4, 5, 6])
         expect(outputs_processed).to eq(4)
         expect(input_mapper.num_processed).to eq(6)
       end
@@ -337,33 +334,33 @@ describe Chef::ChefFS::Parallelizer do
       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)
+          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
-          expect(enum.lazy.take(2).to_a).to eq([1,2])
+          expect(enum.lazy.take(2).to_a).to eq([1, 2])
           expect(outputs_processed).to eq(2)
           expect(input_mapper.num_processed).to eq(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)
+          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
-          expect(enum.lazy.drop(2).to_a).to eq([3,4,5,6])
+          expect(enum.lazy.drop(2).to_a).to eq([3, 4, 5, 6])
           expect(outputs_processed).to eq(4)
           expect(input_mapper.num_processed).to eq(6)
         end
 
         it "lazy enumerable is actually lazy" do
           outputs_processed = 0
-          input_mapper = TestEnumerable.new(1,2,3,4,5,6)
+          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
@@ -381,32 +378,32 @@ describe Chef::ChefFS::Parallelizer do
     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)
+        input_mapper = TestEnumerable.new(1, 2, 3)
         enum = parallelizer.parallelize(input_mapper) do |x|
           outputs_processed += 1
           x
         end
-        expect(enum.map { |x| x }).to eq([1,2,3])
-        expect(enum.map { |x| x }).to eq([1,2,3])
+        expect(enum.map { |x| x }).to eq([1, 2, 3])
+        expect(enum.map { |x| x }).to eq([1, 2, 3])
         expect(outputs_processed).to eq(6)
         expect(input_mapper.num_processed).to eq(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)
+        input_mapper = TestEnumerable.new(1, 2, 3)
         enum = parallelizer.parallelize(input_mapper) do |x|
           outputs_processed += 1
           x
         end
         expect(enum.first).to eq(1)
-        expect(enum.map { |x| x }).to eq([1,2,3])
+        expect(enum.map { |x| x }).to eq([1, 2, 3])
         expect(outputs_processed).to be >= 4
         expect(input_mapper.num_processed).to be >= 4
       end
 
       it "two simultaneous enumerations throws an exception" do
-        enum = parallelizer.parallelize([1,2,3]) { |x| x }
+        enum = parallelizer.parallelize([1, 2, 3]) { |x| x }
         a = enum.enum_for(:each)
         a.next
         expect do
@@ -424,7 +421,7 @@ describe Chef::ChefFS::Parallelizer do
 
     context "And main_thread_processing on" do
       it "succeeds in running" do
-        expect(parallelizer.parallelize([0.5]) { |x| x*2 }.to_a).to eq([1])
+        expect(parallelizer.parallelize([0.5]) { |x| x * 2 }.to_a).to eq([1])
       end
     end
   end
@@ -435,16 +432,16 @@ describe Chef::ChefFS::Parallelizer do
     end
 
     it "does not have contention issues with large numbers of inputs" do
-      expect(parallelizer.parallelize(1.upto(500)) { |x| x+1 }.to_a).to eq(2.upto(501).to_a)
+      expect(parallelizer.parallelize(1.upto(500)) { |x| x + 1 }.to_a).to eq(2.upto(501).to_a)
     end
 
     it "does not have contention issues with large numbers of inputs with ordering off" do
-      expect(parallelizer.parallelize(1.upto(500), :ordered => false) { |x| x+1 }.to_a.sort).to eq(2.upto(501).to_a)
+      expect(parallelizer.parallelize(1.upto(500), :ordered => false) { |x| x + 1 }.to_a.sort).to eq(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 }
+        parallelizer.parallelize(1.upto(500)) { |x| x + 1 }
       end
       outputs = []
       threads = 0.upto(99).map do |i|