Fix tests leaving behind threads

Author: dwelch-r7

lib/metasploit/framework/spec/threads/suite.rb

@@ -100,8 +100,6 @@ def self.configure!
 
                         # unmanaged thread, such as the main VM thread
                         unless thread_uuid
-                          error_lines << "Thread has no uuid, thread name #{thread_name}"
-                          error_lines << "The thread backtrace was:\n#{thread.backtrace ? thread.backtrace.join("\n") : 'nil (no backtrace)'}\n"
                           next
                         end
 

lib/msf/base/sessions/command_shell.rb

@@ -247,7 +247,7 @@ def cmd_sessions(*args)
     session_id = args[0].to_i
     if session_id <= 0
       print_status 'Invalid session id'
-      cmd_sessions_help
+      return cmd_sessions_help
     end
 
     if session_id == self.sid

lib/msf/ui/console/command_dispatcher/session.rb

@@ -182,20 +182,20 @@ def cmd_resource(*args)
                 ::Msf::Config.script_directory + ::File::SEPARATOR + 'resource' + ::File::SEPARATOR + 'meterpreter',
                 ::Msf::Config.user_script_directory + ::File::SEPARATOR + 'resource' + ::File::SEPARATOR + 'meterpreter'
               ].each do |dir|
-                res_path = dir + ::File::SEPARATOR + res
-                if ::File.exist?(res_path)
-                  good_res = res_path
-                  break
-                end
-              end
+                      res_path = dir + ::File::SEPARATOR + res
+                      if ::File.exist?(res_path)
+                        good_res = res_path
+                        break
+                      end
+                    end
                 # let's check to see if it's in the scripts/resource dir (like when tab completed)
               end
-              if good_res
-                client.console.load_resource(good_res)
-              else
+              unless good_res
                 print_error("#{res} is not a valid resource file")
                 next
               end
+
+              client.console.load_resource(good_res)
             end
           end
 
@@ -220,7 +220,8 @@ def cmd_resource_tabs(str, words)
                     ::File.file?(path) and ::File.readable?(path)
                   end
                 end
-              rescue Exception
+              rescue StandardError => e
+                elog('Problem tab completing resource file names in the scripts/resource directories', error: e)
               end
             else
               tabs += tab_complete_filenames(str, words)

spec/lib/msf/base/sessions/command_shell_spec.rb

@@ -5,12 +5,16 @@
 RSpec.describe Msf::Sessions::CommandShell do
   let(:type) { 'shell' }
 
-  it 'should have the correct type' do
-    expect(described_class.type).to eq(type)
+  describe '.type' do
+    it 'should have the correct type' do
+      expect(described_class.type).to eq(type)
+    end
   end
 
-  it 'should be able to cleanup files' do
-    expect(described_class.can_cleanup_files).to eq(true)
+  describe '.can_cleanup_files' do
+    it 'should be able to cleanup files' do
+      expect(described_class.can_cleanup_files).to eq(true)
+    end
   end
 
   context 'when we have a command shell session' do
@@ -23,37 +27,48 @@
     end
     let(:description) { 'Command shell' }
 
-    it 'should have the correct type' do
-      expect(subject.type).to eq(type)
+    describe '#type' do
+      it 'should have the correct type' do
+        expect(subject.type).to eq(type)
+      end
     end
-    it 'should have the correct description' do
-      expect(subject.desc).to eq(description)
+
+    describe '#desc' do
+      it 'should have the correct description' do
+        expect(subject.desc).to eq(description)
+      end
     end
 
-    it 'should not support aborting the process running in the session' do
-      expect(subject.abort_foreground_supported).to be(true)
+    describe '#abort_foreground_supported' do
+      it 'should not support aborting the process running in the session' do
+        expect(subject.abort_foreground_supported).to be(true)
+      end
     end
 
-    it 'should initialise the shell by default' do
-      expect(subject.shell_init).to be(true)
+    describe '#shell_init' do
+      it 'should initialise the shell by default' do
+        expect(subject.shell_init).to be(true)
+      end
     end
 
     describe 'Builtin commands' do
-      %i[help background sessions resource shell download upload source irb pry].each do |command|
-        next if command == :help
+      %i[background sessions resource shell download upload source irb pry].each do |command|
+        before(:each) do
+          allow(subject).to receive("cmd_#{command}_help")
+        end
 
         describe "#cmd_#{command}" do
           context 'when called with the `-h` argument' do
             it 'should call the corresponding help function' do
-              expect(subject).to receive("cmd_#{command}_help")
               subject.send("cmd_#{command}", '-h')
+              expect(subject).to have_received("cmd_#{command}_help")
             end
           end
 
           context 'when called with the `--help` argument' do
             it 'should call the corresponding help function' do
-              expect(subject).to receive("cmd_#{command}_help")
               subject.send("cmd_#{command}", '--help')
+              expect(subject).to have_received("cmd_#{command}_help")
             end
           end
         end
@@ -62,30 +77,37 @@
 
     describe '#run_builtin_cmd' do
       %i[help background sessions resource shell download upload source irb pry].each do |command|
+        before(:each) do
+          allow(subject).to receive("cmd_#{command}")
+        end
         context "when called with `#{command}`" do
           it "should call cmd_#{command}" do
-            expect(subject).to receive("cmd_#{command}")
             subject.run_builtin_cmd(command.to_s, nil)
+            expect(subject).to have_received("cmd_#{command}")
           end
         end
       end
     end
 
     describe '#run_single' do
+      before(:each) do
+        allow(subject).to receive(:run_builtin_cmd)
+        allow(subject).to receive(:shell_write)
+      end
       %i[help background sessions resource shell download upload source irb pry].each do |command|
         context "when called with builtin command `#{command}`" do
           it 'should call the builtin function' do
-            expect(subject).to receive(:run_builtin_cmd)
             subject.run_single(command.to_s)
+            expect(subject).to have_received(:run_builtin_cmd)
           end
         end
       end
 
       context 'when called with a non-builtin command' do
         let(:cmd) { 'some_command' }
         it 'should write the command to the shell' do
-          expect(subject).to receive(:shell_write).with("#{cmd}\n")
           subject.run_single(cmd)
+          expect(subject).to have_received(:shell_write).with("#{cmd}\n")
         end
       end
     end
@@ -94,13 +116,17 @@
       let(:initial_auto_run_script) { 'initial_auto_run_script' }
       let(:auto_run_script) { 'auto_run_script' }
 
+      before(:each) do
+        allow(subject).to receive(:execute_script)
+      end
+
       context 'The datastore is empty' do
         let(:datastore) do
           Msf::DataStore.new
         end
         it 'should not execute any script' do
-          is_expected.not_to receive(:execute_script)
           subject.process_autoruns(datastore)
+          is_expected.not_to have_received(:execute_script)
         end
       end
 
@@ -110,9 +136,10 @@
           datastore['InitialAutoRunScript'] = initial_auto_run_script
           datastore
         end
+
         it 'should execute the script' do
-          is_expected.to receive(:execute_script).with(initial_auto_run_script)
           subject.process_autoruns(datastore)
+          is_expected.to have_received(:execute_script).with(initial_auto_run_script)
         end
       end
 
@@ -123,8 +150,8 @@
           datastore
         end
         it 'should execute the script' do
-          is_expected.to receive(:execute_script).with(auto_run_script)
           subject.process_autoruns(datastore)
+          is_expected.to have_received(:execute_script).with(auto_run_script)
         end
       end
 
@@ -136,9 +163,9 @@
           datastore
         end
         it 'should execute initial script before the auto run script' do
-          is_expected.to receive(:execute_script).ordered.with(initial_auto_run_script)
-          is_expected.to receive(:execute_script).ordered.with(auto_run_script)
           subject.process_autoruns(datastore)
+          is_expected.to have_received(:execute_script).ordered.with(initial_auto_run_script)
+          is_expected.to have_received(:execute_script).ordered.with(auto_run_script)
         end
       end
     end

spec/lib/rex/post/meterpreter/ui/console/command_dispatcher/core_spec.rb

@@ -2,21 +2,22 @@
 
 require 'spec_helper'
 require 'rex/post/meterpreter/ui/console/command_dispatcher/core'
-require 'lib/msf/ui/console/command_dispatcher/session_spec'
 
 RSpec.describe Rex::Post::Meterpreter::Ui::Console::CommandDispatcher::Core do
-  let(:client) do
-    client = Msf::Sessions::Meterpreter.new(nil)
-    client.interacting = true
-    client
-  end
-  let(:shell) do
+  let(:client) { instance_double(Msf::Sessions::Meterpreter) }
+  let(:console) do
     console = Rex::Post::Meterpreter::Ui::Console.new(client)
     console.disable_output = true
     console
   end
 
-  subject(:command_dispatcher) { described_class.new(shell) }
+  before(:each) do
+    allow(client).to receive(:console).and_return(console)
+    allow(client).to receive(:name).and_return('test client name')
+    allow(client).to receive(:sid).and_return('test client sid')
+  end
+
+  subject(:command_dispatcher) { described_class.new(client.console) }
 
   it_behaves_like 'session command dispatcher'
 end

spec/lib/msf/ui/console/command_dispatcher/session_spec.rb renamed to spec/support/shared/examples/msf/ui/console/command_dispatcher/session_spec.rb

@@ -1,6 +1,7 @@
+require 'spec_helper'
+
 RSpec.shared_examples_for 'session command dispatcher' do
   include_context 'Msf::Simple::Framework'
-  # include_context 'Msf::Framework#threads cleaner', verify_cleanup_required: false
 
   describe '#client' do
     subject { command_dispatcher.client }
@@ -9,9 +10,13 @@
 
   describe 'Core commands' do
     describe '#cmd_background' do
+      before(:each) do
+        allow(client).to receive(:interacting=)
+      end
+
       it 'backgrounds the session' do
         subject.cmd_background
-        expect(client.interacting).to be(false)
+        expect(client).to have_received(:interacting=).with(false)
       end
 
       it 'is aliased to #cmd_bg' do
@@ -20,9 +25,13 @@
     end
 
     describe '#cmd_exit' do
+      before(:each) do
+        allow(client).to receive(:exit)
+      end
+
       it 'shuts down the session' do
-        expect(client).to receive(:exit)
         subject.cmd_exit
+        expect(client).to have_received(:exit)
       end
 
       it 'is aliased to #cmd_quit' do
@@ -36,55 +45,66 @@
         allow(client).to receive(:framework).and_return(framework)
         allow(framework).to receive(:history_manager).and_return(history_manager)
         allow(history_manager).to receive(:with_context).and_yield
+        allow(Rex::Ui::Text::IrbShell).to receive(:new).with(client).and_return(irb_shell)
+        allow(irb_shell).to receive(:run)
       end
       let(:irb_shell) { instance_double(Rex::Ui::Text::IrbShell) }
       it 'runs an irb shell instance' do
-        expect(Rex::Ui::Text::IrbShell).to receive(:new).with(client).and_return(irb_shell)
-        expect(irb_shell).to receive(:run)
         subject.cmd_irb
+        expect(Rex::Ui::Text::IrbShell).to have_received(:new).with(client)
+        expect(irb_shell).to have_received(:run)
       end
     end
 
     describe '#cmd_sessions' do
       context 'when switching to a new session' do
+        before(:each) do
+          allow(client).to receive(:interacting=)
+          allow(client).to receive(:next_session=)
+        end
+
         let(:new_session_id) { 2 }
 
         it 'backgrounds the session and switches to the new session' do
           subject.cmd_sessions(new_session_id)
-          expect(client.interacting).to be(false)
-          expect(client.next_session).to eq(new_session_id)
+          expect(client).to have_received(:interacting=).with(false)
+          expect(client).to have_received(:next_session=).with(new_session_id)
         end
       end
     end
 
     describe '#cmd_resource' do
-      context 'there is a valid resource script' do
+      context 'when there is a valid resource script' do
         let(:valid_resource_path) { 'valid/resource/path' }
         before(:each) do
           allow(File).to receive(:exist?).and_return(valid_resource_path)
+          allow(client.console).to receive(:load_resource)
         end
         it 'executes the resource script' do
-          expect(client.console).to receive(:load_resource).with(valid_resource_path)
           subject.cmd_resource(valid_resource_path)
+          expect(client.console).to have_received(:load_resource).with(valid_resource_path)
         end
       end
     end
 
     %i[help background sessions resource irb pry exit].each do |command|
       describe "#cmd_#{command}" do
+        before(:each) do
+          allow(subject).to receive("cmd_#{command}_help")
+        end
         next if %i[help exit].include?(command) # These commands don't require`-h/--help`
 
         context 'when called with the `-h` argument' do
           it 'should call the corresponding help function' do
-            expect(subject).to receive("cmd_#{command}_help")
             subject.send("cmd_#{command}", '-h')
+            expect(subject).to have_received("cmd_#{command}_help")
           end
         end
 
         context 'when called with the `--help` argument' do
           it 'should call the corresponding help function' do
-            expect(subject).to receive("cmd_#{command}_help")
             subject.send("cmd_#{command}", '--help')
+            expect(subject).to have_received("cmd_#{command}_help")
           end
         end
       end