chef-utils 17.10.0 → 17.10.19

data/spec/unit/parallel_map_spec.rb

@@ -1,156 +1,156 @@
-# frozen_string_literal: true
-#
-# 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 "chef-utils/parallel_map"
-
-using ChefUtils::ParallelMap
-
-RSpec.describe ChefUtils::ParallelMap do
-
-  shared_examples_for "common parallel API tests" do
-
-    before(:each) do
-      ChefUtils::DefaultThreadPool.instance.instance_variable_set(:@pool, nil)
-      ChefUtils::DefaultThreadPool.instance.threads = threads
-    end
-
-    after(:each) do
-      ChefUtils::DefaultThreadPool.instance.instance_variable_set(:@pool, nil)
-    end
-
-    it "parallel_map runs in parallel" do
-      # this is implicitly also testing that we run in the caller when we exhaust threads by running threads+1
-      val = threads + 1
-      ret = []
-      start = Time.now
-      (1..val).parallel_map do |i|
-        loop do
-          if val == i
-            ret << i
-            val -= 1
-            break
-          end
-          # we spin for quite awhile to wait for very slow testers if we have to
-          if Time.now - start > 30
-            raise "timed out; deadlocked due to lack of parallelization?"
-          end
-
-          # need to sleep a tiny bit to let other threads schedule
-          sleep 0.000001
-        end
-      end
-      expected = (1..threads + 1).to_a.reverse
-      expect(ret).to eql(expected)
-    end
-
-    it "parallel_each runs in parallel" do
-      # this is implicitly also testing that we run in the caller when we exhaust threads by running threads+1
-      val = threads + 1
-      ret = []
-      start = Time.now
-      (1..val).parallel_each do |i|
-        loop do
-          if val == i
-            ret << i
-            val -= 1
-            break
-          end
-          # we spin for quite awhile to wait for very slow testers if we have to
-          if Time.now - start > 30
-            raise "timed out; deadlocked due to lack of parallelization?"
-          end
-
-          # need to sleep a tiny bit to let other threads schedule
-          sleep 0.000001
-        end
-      end
-      expected = (1..threads + 1).to_a.reverse
-      expect(ret).to eql(expected)
-    end
-
-    it "parallel_map throws exceptions" do
-      expect { (0..10).parallel_map { |i| raise "boom" } }.to raise_error(RuntimeError)
-    end
-
-    it "parallel_each throws exceptions" do
-      expect { (0..10).parallel_each { |i| raise "boom" } }.to raise_error(RuntimeError)
-    end
-
-    it "parallel_map runs" do
-      ans = Timeout.timeout(30) do
-        (1..10).parallel_map { |i| i }
-      end
-      expect(ans).to eql((1..10).to_a)
-    end
-
-    it "parallel_each runs" do
-      Timeout.timeout(30) do
-        (1..10).parallel_each { |i| i }
-      end
-    end
-
-    it "recursive parallel_map will not deadlock" do
-      ans = Timeout.timeout(30) do
-        (1..2).parallel_map { |i| (1..2).parallel_map { |i| i } }
-      end
-      expect(ans).to eql([[1, 2], [1, 2]])
-    end
-
-    it "recursive parallel_each will not deadlock" do
-      Timeout.timeout(30) do
-        (1..2).parallel_each { |i| (1..2).parallel_each { |i| i } }
-      end
-    end
-
-    it "parallel_map is lazy" do
-      ans = Timeout.timeout(30) do
-        (1..).lazy.parallel_map { |i| i }.first(5)
-      end
-      expect(ans).to eql((1..5).to_a)
-    end
-
-    it "parallel_each is lazy" do
-      Timeout.timeout(30) do
-        (1..).lazy.parallel_each { |i| i }.first(5)
-      end
-    end
-  end
-
-  context "with 10 threads" do
-    let(:threads) { 10 }
-    it_behaves_like "common parallel API tests"
-  end
-
-  context "with 0 threads" do
-    let(:threads) { 0 }
-    it_behaves_like "common parallel API tests"
-  end
-
-  context "with 1 threads" do
-    let(:threads) { 1 }
-    it_behaves_like "common parallel API tests"
-  end
-
-  context "flat_each" do
-    it "runs each over items which are nested one level" do
-      sum = 0
-      [ [ 1, 2 ], [3, 4]].flat_each { |i| sum += i }
-      expect(sum).to eql(10)
-    end
-  end
-end
+# frozen_string_literal: true
+#
+# 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 "chef-utils/parallel_map"
+
+using ChefUtils::ParallelMap
+
+RSpec.describe ChefUtils::ParallelMap do
+
+  shared_examples_for "common parallel API tests" do
+
+    before(:each) do
+      ChefUtils::DefaultThreadPool.instance.instance_variable_set(:@pool, nil)
+      ChefUtils::DefaultThreadPool.instance.threads = threads
+    end
+
+    after(:each) do
+      ChefUtils::DefaultThreadPool.instance.instance_variable_set(:@pool, nil)
+    end
+
+    it "parallel_map runs in parallel" do
+      # this is implicitly also testing that we run in the caller when we exhaust threads by running threads+1
+      val = threads + 1
+      ret = []
+      start = Time.now
+      (1..val).parallel_map do |i|
+        loop do
+          if val == i
+            ret << i
+            val -= 1
+            break
+          end
+          # we spin for quite awhile to wait for very slow testers if we have to
+          if Time.now - start > 30
+            raise "timed out; deadlocked due to lack of parallelization?"
+          end
+
+          # need to sleep a tiny bit to let other threads schedule
+          sleep 0.000001
+        end
+      end
+      expected = (1..threads + 1).to_a.reverse
+      expect(ret).to eql(expected)
+    end
+
+    it "parallel_each runs in parallel" do
+      # this is implicitly also testing that we run in the caller when we exhaust threads by running threads+1
+      val = threads + 1
+      ret = []
+      start = Time.now
+      (1..val).parallel_each do |i|
+        loop do
+          if val == i
+            ret << i
+            val -= 1
+            break
+          end
+          # we spin for quite awhile to wait for very slow testers if we have to
+          if Time.now - start > 30
+            raise "timed out; deadlocked due to lack of parallelization?"
+          end
+
+          # need to sleep a tiny bit to let other threads schedule
+          sleep 0.000001
+        end
+      end
+      expected = (1..threads + 1).to_a.reverse
+      expect(ret).to eql(expected)
+    end
+
+    it "parallel_map throws exceptions" do
+      expect { (0..10).parallel_map { |i| raise "boom" } }.to raise_error(RuntimeError)
+    end
+
+    it "parallel_each throws exceptions" do
+      expect { (0..10).parallel_each { |i| raise "boom" } }.to raise_error(RuntimeError)
+    end
+
+    it "parallel_map runs" do
+      ans = Timeout.timeout(30) do
+        (1..10).parallel_map { |i| i }
+      end
+      expect(ans).to eql((1..10).to_a)
+    end
+
+    it "parallel_each runs" do
+      Timeout.timeout(30) do
+        (1..10).parallel_each { |i| i }
+      end
+    end
+
+    it "recursive parallel_map will not deadlock" do
+      ans = Timeout.timeout(30) do
+        (1..2).parallel_map { |i| (1..2).parallel_map { |i| i } }
+      end
+      expect(ans).to eql([[1, 2], [1, 2]])
+    end
+
+    it "recursive parallel_each will not deadlock" do
+      Timeout.timeout(30) do
+        (1..2).parallel_each { |i| (1..2).parallel_each { |i| i } }
+      end
+    end
+
+    it "parallel_map is lazy" do
+      ans = Timeout.timeout(30) do
+        (1..).lazy.parallel_map { |i| i }.first(5)
+      end
+      expect(ans).to eql((1..5).to_a)
+    end
+
+    it "parallel_each is lazy" do
+      Timeout.timeout(30) do
+        (1..).lazy.parallel_each { |i| i }.first(5)
+      end
+    end
+  end
+
+  context "with 10 threads" do
+    let(:threads) { 10 }
+    it_behaves_like "common parallel API tests"
+  end
+
+  context "with 0 threads" do
+    let(:threads) { 0 }
+    it_behaves_like "common parallel API tests"
+  end
+
+  context "with 1 threads" do
+    let(:threads) { 1 }
+    it_behaves_like "common parallel API tests"
+  end
+
+  context "flat_each" do
+    it "runs each over items which are nested one level" do
+      sum = 0
+      [ [ 1, 2 ], [3, 4]].flat_each { |i| sum += i }
+      expect(sum).to eql(10)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chef-utils
 version: !ruby/object:Gem::Version
-  version: 17.10.0
+  version: 17.10.19
 platform: ruby
 authors:
 - Chef Software, Inc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-17 00:00:00.000000000 Z
+date: 2022-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby