(FACT-2420) enable verify_partial_doubles in rspec (#498)

spec/facter/resolvers/aix/ffi_helper_spec.rb

@@ -1,14 +1,12 @@
 # frozen_string_literal: true
 
 describe Facter::Aix::FfiHelper do
-  let(:averages) { double('FFI::MemoryPointer') }
-  let(:averages_size) { double('FFI::MemoryPointer') }
+  let(:averages) { double('FFI::MemoryPointer', size: 24) }
+  let(:averages_size) { double('FFI::MemoryPointer', write_int: 24) }
 
   before do
     allow(FFI::MemoryPointer).to receive(:new).with(:long_long, 3).and_return(averages)
     allow(FFI::MemoryPointer).to receive(:new).with(:int, 1).and_return(averages_size)
-    allow(averages).to receive(:size).and_return(24)
-    allow(averages_size).to receive(:write_int).with(24)
   end
 
   after do

spec/facter/resolvers/bsd/ffi_helper_spec.rb

@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 
 describe Facter::Bsd::FfiHelper do
-  let(:averages) { double('FFI::MemoryPointer') }
+  let(:averages) { double('FFI::MemoryPointer', size: 24) }
 
   before do
     allow(FFI::MemoryPointer).to receive(:new).with(:double, 3).and_return(averages)
-    allow(averages).to receive(:size).and_return(24)
   end
 
   after do

spec/facter/resolvers/windows/fips_resolver_spec.rb

@@ -2,12 +2,14 @@
 
 describe Facter::Resolvers::Windows::Fips do
   describe '#resolve' do
-    let(:reg) { { 'Enabled' => is_fips } }
+    let(:reg) { instance_double('Win32::Registry::HKEY_LOCAL_MACHINE') }
 
     before do
+      allow(reg).to receive(:close)
+      allow(reg).to receive(:[]).with('Enabled').and_return(is_fips)
+      allow(reg).to receive(:any?).and_yield('Enabled', '1')
       allow(Win32::Registry::HKEY_LOCAL_MACHINE).to receive(:open)
         .with('System\\CurrentControlSet\\Control\\Lsa\\FipsAlgorithmPolicy').and_return(reg)
-      allow(reg).to receive(:close)
     end
 
     after do

spec/facter/resolvers/windows/netkvm_resolver_spec.rb

@@ -2,28 +2,30 @@
 
 describe Facter::Resolvers::NetKVM do
   describe '#resolve' do
+    let(:reg) { instance_double('Win32::Registry::HKEY_LOCAL_MACHINE') }
+
     before do
+      allow(reg).to receive(:keys).and_return(reg_value)
+      allow(reg).to receive(:close)
       allow(Win32::Registry::HKEY_LOCAL_MACHINE).to receive(:open)
         .with('SYSTEM\\CurrentControlSet\\Services')
         .and_return(reg)
-      allow(reg).to receive(:keys?)
-      allow(reg).to receive(:close)
     end
 
     after do
       Facter::Resolvers::NetKVM.invalidate_cache
     end
 
     context 'when is not kvm' do
-      let(:reg) { { 'puppet' => 'labs' } }
+      let(:reg_value) { { 'puppet' => 'labs' } }
 
       it 'returns false' do
         expect(Facter::Resolvers::NetKVM.resolve(:kvm)).to be(false)
       end
     end
 
     context 'when is kvm' do
-      let(:reg) { { 'puppet' => 'labs', 'netkvm' => 'info' } }
+      let(:reg_value) { { 'puppet' => 'labs', 'netkvm' => 'info' } }
 
       it 'returns true' do
         expect(Facter::Resolvers::NetKVM.resolve(:kvm)).to be(true)

spec/facter/resolvers/windows/networking_resolver_spec.rb

@@ -64,12 +64,14 @@
 
     context 'when it succeeded to retrieve networking information but all interface are down' do
       let(:error_code) { NetworkingFFI::ERROR_SUCCES }
-      let(:adapter) {  OpenStruct.new(OperStatus: NetworkingFFI::IF_OPER_STATUS_DOWN, Next: next_adapter) }
+      let(:adapter) {  instance_double('FFI::MemoryPointer') }
       let(:next_adapter) { instance_spy(FFI::Pointer) }
 
       before do
         allow(IpAdapterAddressesLh).to receive(:read_list).with(adapter_address).and_yield(adapter)
         allow(IpAdapterAddressesLh).to receive(:new).with(next_adapter).and_return(adapter)
+        allow(adapter).to receive(:[]).with(:OperStatus).and_return(NetworkingFFI::IF_OPER_STATUS_DOWN)
+        allow(adapter).to receive(:[]).with(:Next).and_return(next_adapter)
         allow(adapter).to receive(:to_ptr).and_return(FFI::Pointer::NULL)
       end
 

spec/facter/resolvers/windows/product_release_resolver_spec.rb

@@ -2,28 +2,35 @@
 
 describe Facter::Resolvers::ProductRelease do
   describe '#resolve' do
-    context 'when all fields exist in registry' do
-      let(:reg) { { 'EditionID' => ed, 'InstallationType' => install, 'ProductName' => prod, 'ReleaseId' => release } }
-      let(:ed) { 'ServerStandard' }
-      let(:install) { 'Server' }
-      let(:prod) { 'Windows Server 2019 Standard' }
-      let(:release) { '1809' }
+    let(:reg) { instance_double('Win32::Registry::HKEY_LOCAL_MACHINE') }
+    let(:ed) { 'ServerStandard' }
+    let(:install) { 'Server' }
+    let(:prod) { 'Windows Server 2019 Standard' }
+    let(:release) { '1809' }
 
-      before do
-        allow(Win32::Registry::HKEY_LOCAL_MACHINE).to receive(:open)
-          .with('SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion')
-          .and_return(reg)
-        allow(reg).to receive(:[]).with('EditionID').and_return(ed)
-        allow(reg).to receive(:[]).with('InstallationType').and_return(install)
-        allow(reg).to receive(:[]).with('ProductName').and_return(prod)
-        allow(reg).to receive(:[]).with('ReleaseId').and_return(release)
-        allow(reg).to receive(:close)
-      end
+    before do
+      allow(Win32::Registry::HKEY_LOCAL_MACHINE).to receive(:open)
+        .with('SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion')
+        .and_return(reg)
+      allow(reg).to receive(:each)
+        .and_yield('EditionID', ed)
+        .and_yield('InstallationType', install)
+        .and_yield('ProductName', prod)
+        .and_yield('ReleaseId', release)
 
-      after do
-        Facter::Resolvers::ProductRelease.invalidate_cache
-      end
+      allow(reg).to receive(:[]).with('EditionID').and_return(ed)
+      allow(reg).to receive(:[]).with('InstallationType').and_return(install)
+      allow(reg).to receive(:[]).with('ProductName').and_return(prod)
+      allow(reg).to receive(:[]).with('ReleaseId').and_return(release)
+
+      allow(reg).to receive(:close)
+    end
+
+    after do
+      Facter::Resolvers::ProductRelease.invalidate_cache
+    end
 
+    context 'when all fields exist in registry' do
       it 'detects edition id' do
         expect(Facter::Resolvers::ProductRelease.resolve(:edition_id)).to eql(ed)
       end
@@ -42,24 +49,7 @@
     end
 
     context "when InstallationType doen't exist in registry" do
-      let(:reg) { { 'EditionID' => ed, 'ProductName' => prod, 'ReleaseId' => release } }
-      let(:ed) { 'ServerStandard' }
-      let(:prod) { 'Windows Server 2019 Standard' }
-      let(:release) { '1809' }
-
-      before do
-        allow(Win32::Registry::HKEY_LOCAL_MACHINE).to receive(:open)
-          .with('SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion')
-          .and_return(reg)
-        allow(reg).to receive(:[]).with('EditionID').and_return(ed)
-        allow(reg).to receive(:[]).with('ProductName').and_return(prod)
-        allow(reg).to receive(:[]).with('ReleaseId').and_return(release)
-        allow(reg).to receive(:close)
-      end
-
-      after do
-        Facter::Resolvers::ProductRelease.invalidate_cache
-      end
+      let(:install) { nil }
 
       it 'detects edition id' do
         expect(Facter::Resolvers::ProductRelease.resolve(:edition_id)).to eql(ed)

spec/mocks/ffi_mock.rb

@@ -26,17 +26,42 @@ def attach_function(function, args, return_type); end
     def enum(*); end
 
     def GetAdaptersAddresses(*); end
+
+    def getkerninfo(*); end
+
+    def getloadavg(*); end
+
+    def WSAAddressToStringW(*); end
+
+    def GetNativeSystemInfo(*); end
+
+    def GetUserNameExW(*); end
+
+    def IsUserAnAdmin(*); end
+
+    def RtlGetVersion(*); end
+
+    def GetPerformanceInfo(*); end
+
+    def IsWow64Process(*); end
+
+    def GetCurrentProcess(*); end
   end
 
   class Pointer
     NULL = nil
+
     def write_uint32(); end
 
     def read_uint32(); end
   end
 
   class MemoryPointer
     def initialize(*); end
+
+    def to_ptr; end
+
+    def [](*); end
   end
 
   class Struct

spec/mocks/win32_mock.rb

@@ -4,6 +4,16 @@ module Win32
   module Registry
     class HKEY_LOCAL_MACHINE
       def self.open(*); end
+
+      def close; end
+
+      def any?; end
+
+      def each; end
+
+      def [](*); end
+
+      def keys; end
     end
   end
 end

spec/spec_helper.rb

@@ -58,8 +58,7 @@
     # You should set this unless you have a good reason not to.
     # It defaults to off only for backwards compatibility.
 
-    # TODO: (FACT-2420) - enable this when windows specs are refactored
-    # mocks.verify_partial_doubles = true
+    mocks.verify_partial_doubles = true
   end
 
   config.after do