chef 16.11.7-universal-mingw32 → 17.2.29-universal-mingw32

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

@@ -1,57 +0,0 @@
-
-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")
-        sleep 1 while test_service_state != "stopped"
-      end
-
-      ::Win32::Service.delete("spec-service")
-    end
-
-    # Delete the test_service_file if it exists
-    if File.exist?(test_service_file)
-      File.delete(test_service_file)
-    end
-  end
-
-  # Definition for the test-service
-
-  let(:test_service) do
-    {
-      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(__dir__, "../../platforms/win32/spec_service.rb")),
-      delayed_start: true,
-    }
-  end
-
-  # 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) do
-    "#{ENV["SystemDrive"]}\\windows\\temp\\spec_service_file"
-  end
-end

data/spec/unit/application/knife_spec.rb

@@ -1,241 +0,0 @@
-#
-# Author:: AJ Christensen (<aj@junglist.gen.nz>)
-# Copyright:: Copyright (c) Chef Software 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 "spec_helper"
-require "#{CHEF_SPEC_DATA}/knife_subcommand/test_yourself"
-
-describe Chef::Application::Knife do
-  include SpecHelpers::Knife
-
-  before(:all) do
-    class NoopKnifeCommand < Chef::Knife
-      option :opt_with_default,
-        short: "-D VALUE",
-        long: "-optwithdefault VALUE",
-        default: "default-value"
-
-      def run; end
-    end
-  end
-
-  after(:each) do
-    # reset some really nasty global state
-    NoopKnifeCommand.reset_config_loader!
-  end
-
-  before(:each) do
-    # Prevent code from getting loaded on every test invocation.
-    allow(Chef::Knife).to receive(:load_commands)
-
-    @knife = Chef::Application::Knife.new
-    allow(@knife).to receive(:puts)
-    allow(@knife).to receive(:trap)
-    allow(Chef::Knife).to receive(:list_commands)
-  end
-
-  it "should exit 1 and print the options if no arguments are given at all" do
-    with_argv([]) do
-      expect { @knife.run }.to raise_error(SystemExit) { |e| expect(e.status).to eq(1) }
-    end
-  end
-
-  it "should exit 2 if run without a sub command" do
-    with_argv("--user", "adam") do
-      expect(Chef::Log).to receive(:error).with(/you need to pass a sub\-command/i)
-      expect { @knife.run }.to raise_error(SystemExit) { |e| expect(e.status).to eq(2) }
-    end
-  end
-
-  it "should run a sub command with the applications command line option prototype" do
-    with_argv(*%w{noop knife command with some args}) do
-      knife = double(Chef::Knife)
-      expect(Chef::Knife).to receive(:run).with(ARGV, @knife.options).and_return(knife)
-      expect(@knife).to receive(:exit).with(0)
-      @knife.run
-    end
-  end
-
-  it "should set the colored output to true by default on windows and true on all other platforms as well" do
-    with_argv(*%w{noop knife command}) do
-      expect(@knife).to receive(:exit).with(0)
-      @knife.run
-    end
-    expect(Chef::Config[:color]).to be_truthy
-  end
-
-  context "validate --format option" do
-    it "should set the default format summary" do
-      with_argv(*%w{noop knife command}) do
-        expect(@knife).to receive(:exit).with(0)
-        @knife.run
-        expect(@knife.default_config[:format]).to eq("summary")
-      end
-    end
-
-    it "should raise the error for invalid value" do
-      with_argv(*%w{noop knife command -F abc}) do
-        expect(STDOUT).to receive(:puts).at_least(2).times
-        expect { @knife.run }.to raise_error(SystemExit) { |e| expect(e.status).to eq(2) }
-      end
-    end
-  end
-
-  context "when given fips flags" do
-    context "when Chef::Config[:fips]=false" do
-      before do
-        # This is required because the chef-fips pipeline does
-        # has a default value of true for fips
-        Chef::Config[:fips] = false
-      end
-
-      it "does not initialize fips mode when no flags are passed" do
-        with_argv(*%w{noop knife command}) do
-          expect(@knife).to receive(:exit).with(0)
-          expect(Chef::Config).not_to receive(:enable_fips_mode)
-          @knife.run
-          expect(Chef::Config[:fips]).to eq(false)
-        end
-      end
-
-      it "overwrites the Chef::Config value when passed --fips" do
-        with_argv(*%w{noop knife command --fips}) do
-          expect(@knife).to receive(:exit).with(0)
-          expect(Chef::Config).to receive(:enable_fips_mode)
-          @knife.run
-          expect(Chef::Config[:fips]).to eq(true)
-        end
-      end
-    end
-
-    context "when Chef::Config[:fips]=true" do
-      before do
-        Chef::Config[:fips] = true
-      end
-
-      it "initializes fips mode when passed --fips" do
-        with_argv(*%w{noop knife command --fips}) do
-          expect(@knife).to receive(:exit).with(0)
-          expect(Chef::Config).to receive(:enable_fips_mode)
-          @knife.run
-          expect(Chef::Config[:fips]).to eq(true)
-        end
-      end
-
-      it "overwrites the Chef::Config value when passed --no-fips" do
-        with_argv(*%w{noop knife command --no-fips}) do
-          expect(@knife).to receive(:exit).with(0)
-          expect(Chef::Config).not_to receive(:enable_fips_mode)
-          @knife.run
-          expect(Chef::Config[:fips]).to eq(false)
-        end
-      end
-    end
-  end
-
-  describe "when given a path to the client key" do
-    it "expands a relative path relative to the CWD" do
-      relative_path = ".chef/client.pem"
-      allow(Dir).to receive(:pwd).and_return(CHEF_SPEC_DATA)
-      with_argv(*%W{noop knife command -k #{relative_path}}) do
-        expect(@knife).to receive(:exit).with(0)
-        @knife.run
-      end
-      expect(Chef::Config[:client_key]).to eq(File.join(CHEF_SPEC_DATA, relative_path))
-    end
-
-    it "expands a ~/home/path to the correct full path" do
-      home_path = "~/.chef/client.pem"
-      with_argv(*%W{noop knife command -k #{home_path}}) do
-        expect(@knife).to receive(:exit).with(0)
-        @knife.run
-      end
-      expect(Chef::Config[:client_key]).to eq(File.join(ENV["HOME"], ".chef/client.pem").gsub((File::ALT_SEPARATOR || '\\'), File::SEPARATOR))
-    end
-
-    it "does not expand a full path" do
-      full_path = if windows?
-                    "C:/chef/client.pem"
-                  else
-                    "/etc/chef/client.pem"
-                  end
-      with_argv(*%W{noop knife command -k #{full_path}}) do
-        expect(@knife).to receive(:exit).with(0)
-        @knife.run
-      end
-      expect(Chef::Config[:client_key]).to eq(full_path)
-    end
-  end
-
-  describe "with environment configuration" do
-    before do
-      Chef::Config[:environment] = nil
-    end
-
-    it "should default to no environment" do
-      with_argv(*%w{noop knife command}) do
-        expect(@knife).to receive(:exit).with(0)
-        @knife.run
-      end
-      expect(Chef::Config[:environment]).to eq(nil)
-    end
-
-    it "should load the environment from the config file" do
-      config_file = File.join(CHEF_SPEC_DATA, "environment-config.rb")
-      with_argv(*%W{noop knife command -c #{config_file}}) do
-        expect(@knife).to receive(:exit).with(0)
-        @knife.run
-      end
-      expect(Chef::Config[:environment]).to eq("production")
-    end
-
-    it "should load the environment from the CLI options" do
-      with_argv(*%w{noop knife command -E development}) do
-        expect(@knife).to receive(:exit).with(0)
-        @knife.run
-      end
-      expect(Chef::Config[:environment]).to eq("development")
-    end
-
-    it "should override the config file environment with the CLI environment" do
-      config_file = File.join(CHEF_SPEC_DATA, "environment-config.rb")
-      with_argv(*%W{noop knife command -c #{config_file} -E override}) do
-        expect(@knife).to receive(:exit).with(0)
-        @knife.run
-      end
-      expect(Chef::Config[:environment]).to eq("override")
-    end
-
-    it "should override the config file environment with the CLI environment regardless of order" do
-      config_file = File.join(CHEF_SPEC_DATA, "environment-config.rb")
-      with_argv(*%W{noop knife command -E override -c #{config_file}}) do
-        expect(@knife).to receive(:exit).with(0)
-        @knife.run
-      end
-      expect(Chef::Config[:environment]).to eq("override")
-    end
-
-    it "should run a sub command with the applications command line option prototype" do
-      with_argv(*%w{noop knife command with some args}) do
-        knife = double(Chef::Knife)
-        expect(Chef::Knife).to receive(:run).with(ARGV, @knife.options).and_return(knife)
-        expect(@knife).to receive(:exit).with(0)
-        @knife.run
-      end
-    end
-  end
-
-end

data/spec/unit/chef_fs/parallelizer_spec.rb

@@ -1,479 +0,0 @@
-require "spec_helper"
-require "chef/chef_fs/parallelizer"
-
-# 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::ChefFS::Parallelizer, :not_supported_on_macos 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
-      expect(elapsed_time).to be < 0.6
-      expect(outputs).to eq([ 0.1, 0.3, 0.5 ])
-    end
-
-    context "With :ordered => false (unordered output)" do
-      it "An empty input produces an empty output" do
-        expect(parallelize([], ordered: false) do
-          sleep 10
-        end.to_a).to eql([])
-        expect(elapsed_time).to be < 0.1
-      end
-
-      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})
-        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|
-          sleep val
-          val
-        end
-        expect(enum.map do |value|
-          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"
-        end
-        enum = parallelize(input, ordered: false) { |x| sleep(x); x }
-        results = []
-        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"
-            sleep 0.1
-            raise "hi"
-          end
-          sleep 0.2
-          processed += 1
-          x
-        end
-        results = []
-        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)
-      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"
-        expect(processed).to eq(4)
-      end
-    end
-
-    context "With :ordered => true (ordered output)" do
-      it "An empty input produces an empty output" do
-        expect(parallelize([]) do
-          sleep 10
-        end.to_a).to eql([])
-        expect(elapsed_time).to be < 0.1
-      end
-
-      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})
-        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|
-          sleep val
-          val
-        end.enum_for(:each_with_index)
-        expect(enum.next).to eq([ 0.5, 0 ])
-        expect(enum.next).to eq([ 0.3, 1 ])
-        expect(enum.next).to eq([ 0.1, 2 ])
-        expect(elapsed_time).to be < 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"
-        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"
-            sleep(0.1)
-            raise "hi"
-          end
-          sleep(0.2)
-          processed += 1
-          x
-        end
-        results = []
-        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)
-      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"
-        expect(processed).to eq(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 }
-      expect(enum.map do |value|
-        expect(elapsed_time).to be < (value + 1) * 0.1
-        value
-      end).to eq([ 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
-          parallelizer.parallelize([0], main_thread_processing: false) do |x|
-            started = true
-            sleep(0.3)
-            occupying_job_finished[0] = true
-          end.wait
-        end
-        sleep(0.01) until started
-      end
-
-      after :each do
-        Thread.kill(@thread)
-      end
-
-      it "parallelize with :main_thread_processing = true does not block" do
-        expect(parallelizer.parallelize([1]) do |x|
-          sleep(0.1)
-          x
-        end.to_a).to eq([ 1 ])
-        expect(elapsed_time).to be < 0.2
-      end
-
-      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
-        end.to_a).to eq([ 2 ])
-        expect(elapsed_time).to be > 0.3
-      end
-
-      it "resizing the Parallelizer to 0 waits for the job to stop" do
-        expect(elapsed_time).to be < 0.2
-        parallelizer.resize(0)
-        expect(parallelizer.num_threads).to eq(0)
-        expect(elapsed_time).to be > 0.25
-        expect(@occupying_job_finished).to eq([ true ])
-      end
-
-      it "stopping the Parallelizer waits for the job to finish" do
-        expect(elapsed_time).to be < 0.2
-        parallelizer.stop
-        expect(parallelizer.num_threads).to eq(0)
-        expect(elapsed_time).to be > 0.25
-        expect(@occupying_job_finished).to eq([ true ])
-      end
-
-      it "resizing the Parallelizer to 2 does not stop the job" do
-        expect(elapsed_time).to be < 0.2
-        parallelizer.resize(2)
-        expect(parallelizer.num_threads).to eq(2)
-        expect(elapsed_time).to be < 0.2
-        sleep(0.3)
-        expect(@occupying_job_finished).to eq([ 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
-        expect(enum.count).to eq(6)
-        expect(outputs_processed).to eq(0)
-        expect(input_mapper.num_processed).to eq(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
-        expect(enum.count { |x| x > 1 }).to eq(6)
-        expect(enum.count(2)).to eq(3)
-        expect(outputs_processed).to eq(20)
-        expect(input_mapper.num_processed).to eq(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
-        expect(enum.first).to eq(1)
-        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)
-        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(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)
-        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(outputs_processed).to eq(4)
-        expect(input_mapper.num_processed).to eq(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
-          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)
-          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(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)
-          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)
-          expect(outputs_processed).to eq(0)
-          expect(input_mapper.num_processed).to eq(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
-        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)
-        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(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 }
-        a = enum.enum_for(:each)
-        a.next
-        expect do
-          b = enum.enum_for(:each)
-          b.next
-        end.to raise_error(RuntimeError, "each() called on parallel enumerable twice simultaneously! Bad mojo")
-      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
-        expect(parallelizer.parallelize([0.5]) { |x| x * 2 }.to_a).to eq([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
-      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)
-    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(&:join)
-      outputs.each { |output| expect(output.sort).to eq(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
-      @values.each do |value|
-        @num_processed += 1
-        yield(value)
-      end
-      if @block
-        @block.call do |value|
-          @num_processed += 1
-          yield(value)
-        end
-      end
-    end
-  end
-end