puppet 6.29.0-x86-mingw32 → 7.0.0-x86-mingw32

data/spec/unit/util/suidmanager_spec.rb

@@ -14,14 +14,12 @@ describe Puppet::Util::SUIDManager do
     pwent = double('pwent', :name => 'fred', :uid => 42, :gid => 42)
     allow(Etc).to receive(:getpwuid).with(42).and_return(pwent)
 
-    unless Puppet::Util::Platform.windows?
-      [:euid, :egid, :uid, :gid, :groups].each do |id|
-        allow(Process).to receive("#{id}=") {|value| xids[id] = value}
-      end
+    [:euid, :egid, :uid, :gid, :groups].each do |id|
+      allow(Process).to receive("#{id}=") {|value| xids[id] = value}
     end
   end
 
-  describe "#initgroups", unless: Puppet::Util::Platform.windows? do
+  describe "#initgroups" do
     it "should use the primary group of the user as the 'basegid'" do
       expect(Process).to receive(:initgroups).with('fred', 42)
       described_class.initgroups(42)
@@ -29,7 +27,7 @@ describe Puppet::Util::SUIDManager do
   end
 
   describe "#uid" do
-    it "should allow setting euid/egid", unless: Puppet::Util::Platform.windows? do
+    it "should allow setting euid/egid" do
       Puppet::Util::SUIDManager.egid = user[:gid]
       Puppet::Util::SUIDManager.euid = user[:uid]
 
@@ -39,7 +37,8 @@ describe Puppet::Util::SUIDManager do
   end
 
   describe "#asuser" do
-    it "should not get or set euid/egid when not root", unless: Puppet::Util::Platform.windows? do
+    it "should not get or set euid/egid when not root" do
+      allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
       allow(Process).to receive(:uid).and_return(1)
 
       allow(Process).to receive(:egid).and_return(51)
@@ -50,12 +49,13 @@ describe Puppet::Util::SUIDManager do
       expect(xids).to be_empty
     end
 
-    context "when root and not Windows" do
+    context "when root and not windows" do
       before :each do
         allow(Process).to receive(:uid).and_return(0)
+        allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
       end
 
-      it "should set euid/egid", unless: Puppet::Util::Platform.windows? do
+      it "should set euid/egid" do
         allow(Process).to receive(:egid).and_return(51, 51, user[:gid])
         allow(Process).to receive(:euid).and_return(50, 50, user[:uid])
 
@@ -79,23 +79,29 @@ describe Puppet::Util::SUIDManager do
       end
 
       it "should just yield if user and group are nil" do
-        expect { |b| Puppet::Util::SUIDManager.asuser(nil, nil, &b) }.to yield_control
+        yielded = false
+        Puppet::Util::SUIDManager.asuser(nil, nil) { yielded = true }
+        expect(yielded).to be_truthy
         expect(xids).to eq({})
       end
 
-      it "should just change group if only group is given", unless: Puppet::Util::Platform.windows? do
-        expect { |b| Puppet::Util::SUIDManager.asuser(nil, 42, &b) }.to yield_control
+      it "should just change group if only group is given" do
+        yielded = false
+        Puppet::Util::SUIDManager.asuser(nil, 42) { yielded = true }
+        expect(yielded).to be_truthy
         expect(xids).to eq({ :egid => 42 })
       end
 
-      it "should change gid to the primary group of uid by default", unless: Puppet::Util::Platform.windows? do
+      it "should change gid to the primary group of uid by default" do
         allow(Process).to receive(:initgroups)
 
-        expect { |b| Puppet::Util::SUIDManager.asuser(42, nil, &b) }.to yield_control
+        yielded = false
+        Puppet::Util::SUIDManager.asuser(42) { yielded = true }
+        expect(yielded).to be_truthy
         expect(xids).to eq({ :euid => 42, :egid => 42 })
       end
 
-      it "should change both uid and gid if given", unless: Puppet::Util::Platform.windows? do
+      it "should change both uid and gid if given" do
         # I don't like the sequence, but it is the only way to assert on the
         # internal behaviour in a reliable fashion, given we need multiple
         # sequenced calls to the same methods. --daniel 2012-02-05
@@ -104,23 +110,21 @@ describe Puppet::Util::SUIDManager do
         expect(Puppet::Util::SUIDManager).to receive(:change_group).with(Puppet::Util::SUIDManager.egid, false).ordered()
         expect(Puppet::Util::SUIDManager).to receive(:change_user).with(Puppet::Util::SUIDManager.euid, false).ordered()
 
-        expect { |b| Puppet::Util::SUIDManager.asuser(42, 43, &b) }.to yield_control
+        yielded = false
+        Puppet::Util::SUIDManager.asuser(42, 43) { yielded = true }
+        expect(yielded).to be_truthy
       end
     end
 
-    it "should just yield on Windows", if: Puppet::Util::Platform.windows? do
-      expect { |b| Puppet::Util::SUIDManager.asuser(1, 2, &b) }.to yield_control
+    it "should not get or set euid/egid on Windows", if: Puppet::Util::Platform.windows? do
+      Puppet::Util::SUIDManager.asuser(user[:uid], user[:gid]) {}
+
+      expect(xids).to be_empty
     end
   end
 
   describe "#change_group" do
-    it "raises on Windows", if: Puppet::Util::Platform.windows? do
-      expect {
-        Puppet::Util::SUIDManager.change_group(42, true)
-      }.to raise_error(NotImplementedError, /change_privilege\(\) function is unimplemented/)
-    end
-
-    describe "when changing permanently", unless: Puppet::Util::Platform.windows? do
+    describe "when changing permanently" do
       it "should change_privilege" do
         expect(Process::GID).to receive(:change_privilege) do |gid|
           Process.gid = gid
@@ -146,7 +150,7 @@ describe Puppet::Util::SUIDManager do
       end
     end
 
-    describe "when changing temporarily", unless: Puppet::Util::Platform.windows? do
+    describe "when changing temporarily" do
       it "should change only egid" do
         Puppet::Util::SUIDManager.change_group(42, false)
 
@@ -157,13 +161,7 @@ describe Puppet::Util::SUIDManager do
   end
 
   describe "#change_user" do
-    it "raises on Windows", if: Puppet::Util::Platform.windows? do
-      expect {
-        Puppet::Util::SUIDManager.change_user(42, true)
-      }.to raise_error(NotImplementedError, /initgroups\(\) function is unimplemented/)
-    end
-
-    describe "when changing permanently", unless: Puppet::Util::Platform.windows? do
+    describe "when changing permanently" do
       it "should change_privilege" do
         expect(Process::UID).to receive(:change_privilege) do |uid|
           Process.uid = uid
@@ -193,7 +191,7 @@ describe Puppet::Util::SUIDManager do
       end
     end
 
-    describe "when changing temporarily", unless: Puppet::Util::Platform.windows? do
+    describe "when changing temporarily" do
       it "should change only euid and groups" do
         allow(Puppet::Util::SUIDManager).to receive(:initgroups).and_return([])
         Puppet::Util::SUIDManager.change_user(42, false)
@@ -223,7 +221,12 @@ describe Puppet::Util::SUIDManager do
   end
 
   describe "#root?" do
-    describe "on POSIX systems", unless: Puppet::Util::Platform.windows? do
+    describe "on POSIX systems" do
+      before :each do
+        allow(Puppet.features).to receive(:posix?).and_return(true)
+        allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
+      end
+
       it "should be root if uid is 0" do
         allow(Process).to receive(:uid).and_return(0)
 
@@ -237,7 +240,7 @@ describe Puppet::Util::SUIDManager do
       end
     end
 
-    describe "on Windows", :if => Puppet::Util::Platform.windows? do
+    describe "on Microsoft Windows", :if => Puppet::Util::Platform.windows? do
       it "should be root if user is privileged" do
         allow(Puppet::Util::Windows::User).to receive(:admin?).and_return(true)
 
@@ -258,19 +261,13 @@ describe 'Puppet::Util::SUIDManager#groups=' do
     Puppet::Util::SUIDManager
   end
 
-  it "raises on Windows", if: Puppet::Util::Platform.windows? do
-    expect {
-      subject.groups = []
-    }.to raise_error(NotImplementedError, /groups=\(\) function is unimplemented/)
-  end
-
-  it "(#3419) should rescue Errno::EINVAL on OS X", unless: Puppet::Util::Platform.windows? do
+  it "(#3419) should rescue Errno::EINVAL on OS X" do
     expect(Process).to receive(:groups=).and_raise(Errno::EINVAL, 'blew up')
     expect(subject).to receive(:osx_maj_ver).and_return('10.7').twice
     subject.groups = ['list', 'of', 'groups']
   end
 
-  it "(#3419) should fail if an Errno::EINVAL is raised NOT on OS X", unless: Puppet::Util::Platform.windows? do
+  it "(#3419) should fail if an Errno::EINVAL is raised NOT on OS X" do
     expect(Process).to receive(:groups=).and_raise(Errno::EINVAL, 'blew up')
     expect(subject).to receive(:osx_maj_ver).and_return(false)
     expect { subject.groups = ['list', 'of', 'groups'] }.to raise_error(Errno::EINVAL)

data/spec/unit/util/windows/sid_spec.rb

@@ -131,74 +131,33 @@ describe "Puppet::Util::Windows::SID", :if => Puppet::Util::Platform.windows? do
       expect(subject.name_to_principal(unknown_name)).to be_nil
     end
 
-    it "should print a debug message if the account does not exist" do
-      expect(Puppet).to receive(:debug).with(/No mapping between account names and security IDs was done/)
-      subject.name_to_principal(unknown_name)
-    end
-
     it "should return a Puppet::Util::Windows::SID::Principal instance for any valid sid" do
       expect(subject.name_to_principal(sid)).to be_an_instance_of(Puppet::Util::Windows::SID::Principal)
     end
 
-    it "should not print debug messages for valid sid" do
-      expect(Puppet).not_to receive(:debug).with(/Could not retrieve raw SID bytes from/)
-      expect(Puppet).not_to receive(:debug).with(/No mapping between account names and security IDs was done/)
-      subject.name_to_principal(sid)
-    end
-
-    it "should print a debug message for invalid sid" do
-      expect(Puppet).not_to receive(:debug).with(/Could not retrieve raw SID bytes from/)
-      expect(Puppet).to receive(:debug).with(/No mapping between account names and security IDs was done/)
-      subject.name_to_principal('S-1-5-21-INVALID-SID')
-    end
-
     it "should accept unqualified account name" do
       # NOTE: lookup by name works in localized environments only for a few instances
       # this works in French Windows, even though the account is really Syst\u00E8me
       expect(subject.name_to_principal('SYSTEM').sid).to eq(sid)
     end
 
-    it "should not print debug messages for unqualified account name" do
-      expect(Puppet).not_to receive(:debug).with(/Could not retrieve raw SID bytes from/)
-      expect(Puppet).not_to receive(:debug).with(/No mapping between account names and security IDs was done/)
-      subject.name_to_principal('SYSTEM')
-    end
-
     it "should be case-insensitive" do
       # NOTE: lookup by name works in localized environments only for a few instances
       # this works in French Windows, even though the account is really Syst\u00E8me
       expect(subject.name_to_principal('SYSTEM')).to eq(subject.name_to_principal('system'))
     end
 
-    it "should not print debug messages for wrongly cased account name" do
-      expect(Puppet).not_to receive(:debug).with(/Could not retrieve raw SID bytes from/)
-      expect(Puppet).not_to receive(:debug).with(/No mapping between account names and security IDs was done/)
-      subject.name_to_principal('system')
-    end
-
     it "should be leading and trailing whitespace-insensitive" do
       # NOTE: lookup by name works in localized environments only for a few instances
       # this works in French Windows, even though the account is really Syst\u00E8me
       expect(subject.name_to_principal('SYSTEM')).to eq(subject.name_to_principal(' SYSTEM '))
     end
 
-    it "should not print debug messages for account name with leading and trailing whitespace" do
-      expect(Puppet).not_to receive(:debug).with(/Could not retrieve raw SID bytes from/)
-      expect(Puppet).not_to receive(:debug).with(/No mapping between account names and security IDs was done/)
-      subject.name_to_principal(' SYSTEM ')
-    end
-
     it "should accept domain qualified account names" do
       # NOTE: lookup by name works in localized environments only for a few instances
       # this works in French Windows, even though the account is really AUTORITE NT\\Syst\u00E8me
       expect(subject.name_to_principal('NT AUTHORITY\SYSTEM').sid).to eq(sid)
     end
-
-    it "should not print debug messages for domain qualified account names" do
-      expect(Puppet).not_to receive(:debug).with(/Could not retrieve raw SID bytes from/)
-      expect(Puppet).not_to receive(:debug).with(/No mapping between account names and security IDs was done/)
-      subject.name_to_principal('NT AUTHORITY\SYSTEM')
-    end
   end
 
   context "#ads_to_principal" do

data/spec/unit/util/windows/string_spec.rb

@@ -4,15 +4,13 @@ require 'spec_helper'
 require 'puppet/util/windows'
 
 describe "Puppet::Util::Windows::String", :if => Puppet::Util::Platform.windows? do
-  UTF16_NULL = [0, 0]
-
   def wide_string(str)
     Puppet::Util::Windows::String.wide_string(str)
   end
 
   def converts_to_wide_string(string_value)
     expected = string_value.encode(Encoding::UTF_16LE)
-    expected_bytes = expected.bytes.to_a + UTF16_NULL
+    expected_bytes = expected.bytes.to_a
 
     expect(wide_string(string_value).bytes.to_a).to eq(expected_bytes)
   end

data/spec/unit/util/yaml_spec.rb

@@ -1,5 +1,6 @@
 # coding: utf-8
 require 'spec_helper'
+
 require 'puppet/util/yaml'
 
 describe Puppet::Util::Yaml do
@@ -9,21 +10,21 @@ describe Puppet::Util::Yaml do
 
   shared_examples_for 'yaml file loader' do |load_method|
     it 'returns false when the file is empty' do
-      file_path = file_containing('input', '')
+      Puppet::FileSystem.touch(filename)
 
-      expect(load_method.call(file_path)).to eq(false)
+      expect(load_method.call(filename)).to eq(false)
     end
 
     it 'reads a YAML file from disk' do
-      file_path = file_containing('input', YAML.dump({ "my" => "data" }))
+      write_file(filename, YAML.dump({ "my" => "data" }))
 
-      expect(load_method.call(file_path)).to eq({ "my" => "data" })
+      expect(load_method.call(filename)).to eq({ "my" => "data" })
     end
 
     it 'reads YAML as UTF-8' do
-      file_path = file_containing('input', YAML.dump({ "my" => "𠜎" }))
+      write_file(filename, YAML.dump({ "my" => "𠜎" }))
 
-      expect(load_method.call(file_path)).to eq({ "my" => "𠜎" })
+      expect(load_method.call(filename)).to eq({ "my" => "𠜎" })
     end
   end
 
@@ -118,11 +119,11 @@ FACTS
     it_should_behave_like 'yaml file loader', Puppet::Util::Yaml.method(:safe_load_file)
 
     it 'raises an error when the file is invalid YAML' do
-      file_path = file_containing('input', '{ invalid')
+      write_file(filename, '{ invalid')
 
       expect {
-        Puppet::Util::Yaml.safe_load_file(file_path)
-      }.to raise_error(Puppet::Util::Yaml::YamlLoadError, %r[\(#{file_path}\): .* at line \d+ column \d+])
+        Puppet::Util::Yaml.safe_load_file(filename)
+      }.to raise_error(Puppet::Util::Yaml::YamlLoadError, %r[\(#{filename}\): .* at line \d+ column \d+])
     end
 
     it 'raises an error when the filename is illegal' do
@@ -138,89 +139,9 @@ FACTS
     end
   end
 
-  context "#safe_load_file_if_valid" do
-    before do
-      Puppet[:log_level] = 'debug'
-    end
-
-    it_should_behave_like 'yaml file loader', Puppet::Util::Yaml.method(:safe_load_file_if_valid)
-
-    it 'returns nil when the file is invalid YAML and debug logs about it' do
-      file_path = file_containing('input', '{ invalid')
-
-      expect(Puppet).to receive(:debug)
-        .with(/Could not retrieve YAML content .+ expected ',' or '}'/).and_call_original
-
-      expect(Puppet::Util::Yaml.safe_load_file_if_valid(file_path)).to eql(nil)
-    end
-
-    it 'returns nil when the filename is illegal and debug logs about it' do
-      expect(Puppet).to receive(:debug)
-        .with(/Could not retrieve YAML content .+: pathname contains null byte/).and_call_original
-
-      expect(Puppet::Util::Yaml.safe_load_file_if_valid("not\0allowed")).to eql(nil)
-    end
-
-    it 'returns nil when the file does not exist and debug logs about it' do
-      expect(Puppet).to receive(:debug)
-        .with(/Could not retrieve YAML content .+: No such file or directory/).and_call_original
-
-      expect(Puppet::Util::Yaml.safe_load_file_if_valid('does/not/exist.yaml')).to eql(nil)
-    end
-  end
-
-  context '#load_file' do
-    it_should_behave_like 'yaml file loader', Puppet::Util::Yaml.method(:load_file)
-
-    it 'raises an error when the file is invalid YAML' do
-      file_path = file_containing('input', '{ invalid')
-
-      expect {
-        Puppet::Util::Yaml.load_file(file_path)
-      }.to raise_error(Puppet::Util::Yaml::YamlLoadError, %r{\(#{file_path}\): .* at line \d+ column \d+})
-    end
-
-    it 'raises an error when the filename is illegal' do
-      expect {
-        Puppet::Util::Yaml.load_file("not\0allowed")
-      }.to raise_error(Puppet::Util::Yaml::YamlLoadError, /null byte/)
-    end
-
-    it 'raises an error when the file does not exist' do
-      expect {
-        Puppet::Util::Yaml.load_file('does/not/exist.yaml')
-      }.to raise_error(Puppet::Util::Yaml::YamlLoadError, /No such file or directory/)
-    end
-
-    it 'allows return value to be overridden' do
-      file_path = file_containing('input', '')
-
-      expect(Puppet::Util::Yaml.load_file(file_path, {})).to eq({})
-    end
-
-    it 'loads arbitrary objects' do
-      file_path = file_containing('input', "--- !ruby/object {}\n")
-
-      expect(Puppet::Util::Yaml.load_file(file_path, {})).to be_instance_of(Object)
-    end
-
-    it 'should allow one to strip ruby tags that would otherwise not parse' do
-     file_path = file_containing('input', "---\nweirddata: !ruby/hash:Not::A::Valid::Class {}")
-
-      expect(Puppet::Util::Yaml.load_file(file_path, {}, true)).to eq({"weirddata" => {}})
-    end
-
-    it 'should not strip non-ruby tags' do
-      file_path = file_containing('input', "---\nweirddata: !binary |-\n          e21kNX04MTE4ZGY2NmM5MTc3OTg4ZWE4Y2JiOWEzMjMyNzFkYg==")
-
-      expect(Puppet::Util::Yaml.load_file(file_path, {}, true)).to eq({"weirddata" => "{md5}8118df66c9177988ea8cbb9a323271db"})
-    end
-
-    it 'writes data formatted as YAML to disk' do
-      file_path = file_containing('input', '')
-      Puppet::Util::Yaml.dump({ "my" => "data" }, file_path)
-
-      expect(Puppet::Util::Yaml.load_file(file_path)).to eq({ "my" => "data" })
+  def write_file(name, contents)
+    File.open(name, "w:UTF-8") do |fh|
+      fh.write(contents)
     end
   end
 end

data/spec/unit/util_spec.rb

@@ -3,12 +3,6 @@ require 'spec_helper'
 describe Puppet::Util do
   include PuppetSpec::Files
 
-  # Discriminator for tests that attempts to unset HOME since that, for reasons currently unknown,
-  # doesn't work in Ruby >= 2.4.0
-  def self.gte_ruby_2_4
-    @gte_ruby_2_4 ||= SemanticPuppet::Version.parse(RUBY_VERSION) >= SemanticPuppet::Version.parse('2.4.0')
-  end
-
   if Puppet::Util::Platform.windows?
     def set_mode(mode, file)
       Puppet::Util::Windows::Security.set_mode(mode, file)
@@ -315,7 +309,7 @@ describe Puppet::Util do
 
     describe "when using platform :posix" do
       before :each do
-        allow(Puppet.features).to receive(:posix?).and_return(true)
+        allow(Puppet.features).to receive(:posix).and_return(true)
         allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
       end
 
@@ -328,7 +322,7 @@ describe Puppet::Util do
 
     describe "when using platform :windows" do
       before :each do
-        allow(Puppet.features).to receive(:posix?).and_return(false)
+        allow(Puppet.features).to receive(:posix).and_return(false)
         allow(Puppet::Util::Platform).to receive(:windows?).and_return(true)
       end
 
@@ -462,7 +456,7 @@ describe Puppet::Util do
 
     describe "when using platform :posix" do
       before :each do
-        allow(Puppet.features).to receive(:posix?).and_return(true)
+        allow(Puppet.features).to receive(:posix).and_return(true)
         allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
       end
 
@@ -501,7 +495,7 @@ describe Puppet::Util do
 
     describe "when using platform :windows" do
       before :each do
-        allow(Puppet.features).to receive(:posix?).and_return(false)
+        allow(Puppet.features).to receive(:posix).and_return(false)
         allow(Puppet::Util::Platform).to receive(:windows?).and_return(true)
       end
 
@@ -539,6 +533,7 @@ describe Puppet::Util do
       expect(Puppet::Util.uri_to_path(URI.parse('http://foo/bar%20baz'))).to eq('/bar baz')
     end
 
+
     [
       "http://foo/A%DB%BF%E1%9A%A0%F0%A0%9C%8E",
       "http://foo/A%DB%BF%E1%9A%A0%F0%A0%9C%8E".force_encoding(Encoding::ASCII)
@@ -588,15 +583,7 @@ describe Puppet::Util do
     end
   end
 
-  describe "safe_posix_fork on Windows and JRuby", if: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
-    it "raises not implemented error" do
-      expect {
-        Puppet::Util.safe_posix_fork
-      }.to raise_error(NotImplementedError, /fork/)
-    end
-  end
-
-  describe "safe_posix_fork", unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
+  describe "safe_posix_fork" do
     let(:pid) { 5501 }
 
     before :each do
@@ -676,18 +663,6 @@ describe Puppet::Util do
       expect(Puppet::Util.which('doesnotexist')).to be_nil
     end
 
-    it "should warn if the user's HOME is not set but their PATH contains a ~", :unless => gte_ruby_2_4 do
-      env_path = %w[~/bin /usr/bin /bin].join(File::PATH_SEPARATOR)
-
-      env = {:HOME => nil, :PATH => env_path}
-      env.merge!({:HOMEDRIVE => nil, :USERPROFILE => nil}) if Puppet::Util::Platform.windows?
-
-      expect(Puppet::Util::Warnings).to receive(:warnonce).once
-      Puppet::Util.withenv(env) do
-        Puppet::Util.which('foo')
-      end
-    end
-
     it "should reject directories" do
       expect(Puppet::Util.which(base)).to be_nil
     end

data/tasks/generate_cert_fixtures.rake

@@ -37,21 +37,19 @@ task(:gen_cert_fixtures) do
   #                                   |   |
   # signed.pem                        |   +- /CN=signed
   # revoked.pem                       |   +- /CN=revoked
+  # 127.0.0.1.pem                     |   +- /CN=127.0.0.1 (with dns alt names)
   # tampered-cert.pem                 |   +- /CN=signed (with different public key)
   # ec.pem                            |   +- /CN=ec (with EC private key)
-  # oid.pem                           |   +- /CN=oid (with custom oid)
   #                                   |
-  # 127.0.0.1.pem                     +- /CN=127.0.0.1 (with dns alt names)
-  #                                   |
-  # intermediate-agent.pem            +- /CN=Test CA Agent Subauthority
-  #                                   |   |
-  # pluto.pem                         |   +- /CN=pluto
+  #                                   + /CN=Test CA Agent Subauthority
+  #                                   |  |
+  # pluto.pem                         |  +- /CN=pluto
   #                                   |
   # bad-int-basic-constraints.pem     +- /CN=Test CA Subauthority (bad isCA constraint)
   #
   # bad-basic-constraints.pem        /CN=Test CA (bad isCA constraint)
   #
-  # unknown-ca.pem                   /CN=Unknown CA
+  # unknown-ca.pemm                  /CN=Unknown CA
   #                                   |
   # unknown-127.0.0.1.pem             +- /CN=127.0.0.1
   #
@@ -105,14 +103,6 @@ task(:gen_cert_fixtures) do
   save(dir, '127.0.0.1.pem', signed[:cert])
   save(dir, '127.0.0.1-key.pem', signed[:private_key])
 
-  # Create an SSL cert with extensions containing custom oids
-  extensions = [
-    ['1.3.6.1.4.1.34380.1.2.1.1', OpenSSL::ASN1::UTF8String.new('somevalue'), false],
-  ]
-  oid = ca.create_cert('oid', inter[:cert], inter[:private_key], extensions: extensions)
-  save(dir, 'oid.pem', oid[:cert])
-  save(dir, 'oid-key.pem', oid[:private_key])
-
   # Create a leaf/entity key and cert for host "revoked", issued by "Test CA Subauthority"
   # and revoke the cert
   revoked = ca.create_cert('revoked', inter[:cert], inter[:private_key])
@@ -183,12 +173,12 @@ task(:gen_cert_fixtures) do
 
   # Create a request, but replace its public key after it's signed
   tampered_csr = ca.create_request('signed')[:csr]
-  tampered_csr.public_key = OpenSSL::PKey::RSA.new(2048).public_key
+  tampered_csr.public_key = OpenSSL::PKey::RSA.new(1024).public_key
   save(dir, 'tampered-csr.pem', tampered_csr)
 
   # Create a cert issued from the real intermediate CA, but replace its
   # public key
   tampered_cert = ca.create_cert('signed', inter[:cert], inter[:private_key])[:cert]
-  tampered_cert.public_key = OpenSSL::PKey::RSA.new(2048).public_key
+  tampered_cert.public_key = OpenSSL::PKey::RSA.new(1024).public_key
   save(dir, 'tampered-cert.pem', tampered_cert)
 end

data/tasks/parallel.rake

@@ -5,9 +5,9 @@ require 'thread'
 begin
   require 'rspec'
   require 'rspec/core/formatters/helpers'
-  require 'etc'
+  require 'facter'
 rescue LoadError
-  # Don't define the task if we don't have rspec present
+  # Don't define the task if we don't have rspec or facter present
 else
   module Parallel
     module RSpec
@@ -401,7 +401,7 @@ else
       # Default group size in rspec examples
       DEFAULT_GROUP_SIZE = 1000
 
-      process_count = [(args[:process_count] || Etc.nprocessors).to_i, 1].max
+      process_count = [(args[:process_count] || Facter.value("processorcount")).to_i, 1].max
       group_size = [(args[:group_size] || DEFAULT_GROUP_SIZE).to_i, 1].max
 
       abort unless Parallel::RSpec::Parallelizer.new(process_count, group_size, color_output?, args.extras).run