debugger 1.2.4 → 1.3.0

data/test/source_test.rb

@@ -0,0 +1,44 @@
+require_relative 'test_helper'
+
+describe "Source Command" do
+  include TestDsl
+
+  let(:filename) { 'source_example.txt' }
+  before do
+    File.open(filename, 'w') do |f|
+      f.puts 'break 2'
+      f.puts 'break 3 if true'
+    end
+  end
+  after do
+    FileUtils.rm(filename)
+  end
+
+  it "must run commands from file" do
+    enter "source #{filename}"
+    debug_file 'source' do
+      Debugger.breakpoints[0].pos.must_equal 2
+      Debugger.breakpoints[1].pos.must_equal 3
+      Debugger.breakpoints[1].expr.must_equal "true"
+    end
+  end
+
+  it "must be able to use shortcut" do
+    enter "so #{filename}"
+    debug_file('source') { Debugger.breakpoints[0].pos.must_equal 2 }
+  end
+
+  it "must show an error if file is not found" do
+    enter "source blabla"
+    debug_file 'source'
+    check_output_includes /Command file '.*blabla' is not found/, interface.error_queue
+  end
+
+  describe "Post Mortem" do
+    it "must work in post-mortem mode" do
+      enter 'cont', "so #{filename}"
+      debug_file('post_mortem') { Debugger.breakpoints[0].pos.must_equal 3 }
+    end
+  end
+
+end

data/test/stepping_test.rb

@@ -0,0 +1,118 @@
+require_relative 'test_helper'
+
+describe "Stepping Commands" do
+  include TestDsl
+
+  describe "Next Command" do
+    describe "Usual mode" do
+      before { enter 'break 10', 'cont' }
+
+      it "must go to the next line if forced by a setting" do
+        temporary_change_hash_value(Debugger::Command.settings, :force_stepping, true) do
+          enter 'next'
+          debug_file('stepping') { state.line.must_equal 11 }
+        end
+      end
+
+      it "must go to the next line by shortcut" do
+        temporary_change_hash_value(Debugger::Command.settings, :force_stepping, true) do
+          enter 'n'
+          debug_file('stepping') { state.line.must_equal 11 }
+        end
+      end
+
+      it "must leave on the same line if forced by a setting" do
+        temporary_change_hash_value(Debugger::Command.settings, :force_stepping, false) do
+          enter 'next'
+          debug_file('stepping') { state.line.must_equal 10 }
+        end
+      end
+
+      it "must go to the specified number of lines forward by default" do
+        temporary_change_hash_value(Debugger::Command.settings, :force_stepping, true) do
+          enter 'next 2'
+          debug_file('stepping') { state.line.must_equal 21 }
+        end
+      end
+
+      it "must go to the next line if forced to do that by 'plus' sign" do
+        enter 'next+'
+        debug_file('stepping') { state.line.must_equal 11 }
+      end
+
+      it "must leave on the same line if forced to do that by 'minus' sign" do
+        enter 'next-'
+        debug_file('stepping') { state.line.must_equal 10 }
+      end
+
+      it "must ignore the setting if 'minus' is specified" do
+        enter 'next-'
+        debug_file('stepping') { state.line.must_equal 10 }
+      end
+    end
+
+    describe "Post Mortem" do
+      temporary_change_hash_value(Debugger::Command.settings, :autoeval, false)
+      it "must not work in post-mortem mode" do
+        enter 'cont', "next"
+        debug_file('post_mortem')
+        check_output_includes 'Unknown command: "next".  Try "help".', interface.error_queue
+      end
+    end
+  end
+
+
+  describe "Step Command" do
+    describe "Usual mode" do
+      before { enter 'break 10', 'cont' }
+
+      it "must go to the step line if forced by a setting" do
+        temporary_change_hash_value(Debugger::Command.settings, :force_stepping, true) do
+          enter 'step'
+          debug_file('stepping') { state.line.must_equal 11 }
+        end
+      end
+
+      it "must go to the next line by shortcut" do
+        temporary_change_hash_value(Debugger::Command.settings, :force_stepping, true) do
+          enter 's'
+          debug_file('stepping') { state.line.must_equal 11 }
+        end
+      end
+
+      it "must leave on the same line if forced by a setting" do
+        temporary_change_hash_value(Debugger::Command.settings, :force_stepping, false) do
+          enter 'step'
+          debug_file('stepping') { state.line.must_equal 10 }
+        end
+      end
+
+      it "must go to the specified number of lines forward by default" do
+        temporary_change_hash_value(Debugger::Command.settings, :force_stepping, true) do
+          enter 'step 2'
+          debug_file('stepping') { state.line.must_equal 15 }
+        end
+      end
+
+      it "must go to the step line if forced to do that by 'plus' sign" do
+        enter 'step+'
+        debug_file('stepping') { state.line.must_equal 11 }
+      end
+
+      it "must leave on the same line if forced to do that by 'minus' sign" do
+        enter 'step-'
+        debug_file('stepping') { state.line.must_equal 10 }
+      end
+    end
+
+    describe "Post Mortem" do
+      temporary_change_hash_value(Debugger::Command.settings, :autoeval, false)
+      it "must not work in post-mortem mode" do
+        enter 'cont', "step"
+        debug_file('post_mortem')
+        check_output_includes 'Unknown command: "step".  Try "help".', interface.error_queue
+      end
+    end
+  end
+
+end

data/test/support/breakpoint.rb

@@ -0,0 +1,12 @@
+module Debugger
+  class Breakpoint
+
+    def inspect
+      values = %w{id pos source expr hit_condition hit_count hit_value enabled?}.map do |field|
+        "#{field}: #{send(field)}"
+      end.join(", ")
+      "#<Debugger::Breakpoint #{values}>"
+    end
+
+  end
+end

data/test/support/context.rb

@@ -0,0 +1,14 @@
+module Debugger
+  class Context
+
+    def inspect
+      values = %w{
+        thread thnum stop_reason suspended? tracing ignored? stack_size dead? frame_line frame_file frame_self
+      }.map do |field|
+        "#{field}: #{send(field)}"
+      end.join(", ")
+      "#<Debugger::Context #{values}>"
+    end
+
+  end
+end

data/test/support/matchers.rb

@@ -0,0 +1,67 @@
+module MiniTest::Assertions
+
+  # This matcher checks that given collection is included into the original collection,
+  # and in correct order. It accepts both strings and regexps.
+  #
+  # Examples:
+  #
+  #   assert_includes_in_order(%w{1 2 3 4 5}, %w{1 3 5})            # => pass
+  #   assert_includes_in_order(%w{1 2 3 4 5}, %w{1 5 3})            # => fail
+  #   assert_includes_in_order(w{1 2 3 4 5}, ["1", /\d+/, "5"])     # => pass
+  #   assert_includes_in_order(w{1 2 3 4 5}, ["1", /\[a-z]+/, "5"]) # => fail
+  #
+  def assert_includes_in_order(given_collection, original_collection, msg = nil)
+    msg = message(msg) do
+      "Expected #{mu_pp(original_collection)} to include #{mu_pp(given_collection)} in order"
+    end
+    assert includes_in_order_result(original_collection, given_collection), msg
+  end
+
+  def refute_includes_in_order(given_collection, original_collection, msg = nil)
+    msg = message(msg) do
+      "Expected #{mu_pp(original_collection)} to not include #{mu_pp(given_collection)} in order"
+    end
+    refute includes_in_order_result(original_collection, given_collection), msg
+  end
+
+
+  private
+
+    def includes_in_order_result(original_collection, given_collection)
+      result = true
+      given_collection.each do |given_item|
+        result &&= case given_item
+          when String
+            index = original_collection.index(given_item)
+            if index
+              original_collection = original_collection[(index + 1)..-1]
+              true
+            else
+              false
+            end
+          when Regexp
+            index = nil
+            original_collection.each_with_index do |original_item, i|
+              if original_item =~ given_item
+                index = i
+                break
+              end
+            end
+            if index
+              original_collection = original_collection[(index + 1)..-1]
+              true
+            else
+              false
+            end
+          else
+            false
+          end
+      end
+      result
+    end
+end
+
+module MiniTest::Expectations
+  infect_an_assertion :assert_includes_in_order, :must_include_in_order
+  infect_an_assertion :refute_includes_in_order, :wont_include_in_order
+end

data/test/support/mocha_extensions.rb

@@ -0,0 +1,71 @@
+module Mocha
+  class Expectation
+
+    # Allows to specify a block to execute when expectation will be matched.
+    # This way, we can specify dynamic values to return or just make some side effects
+    #
+    # Example:
+    #
+    #   foo.expects(:bar).with('bla').calls { 2 + 3 }
+    #   foo.bar('bla') # => 5
+    #
+    def calls(&block)
+      @calls ||= Call.new
+      @calls += Call.new(block)
+      self
+    end
+
+    def invoke_with_calls(arguments, &block)
+      invoke_without_calls(&block) || (@calls.next(arguments, &block) if @calls)
+    end
+    alias_method :invoke_without_calls, :invoke
+    alias_method :invoke, :invoke_with_calls
+
+  end
+
+  class Mock
+
+    # We monkey-patch that method to be able to pass arguments to Expectation#invoke method
+    def method_missing(symbol, *arguments, &block)
+      if @responder and not @responder.respond_to?(symbol)
+        raise NoMethodError, "undefined method `#{symbol}' for #{self.mocha_inspect} which responds like #{@responder.mocha_inspect}"
+      end
+      if matching_expectation_allowing_invocation = @expectations.match_allowing_invocation(symbol, *arguments)
+        # We change this line - added arguments
+        matching_expectation_allowing_invocation.invoke(arguments, &block)
+      else
+        if (matching_expectation = @expectations.match(symbol, *arguments)) || (!matching_expectation && !@everything_stubbed)
+          # We change this line - added arguments
+          matching_expectation.invoke(arguments, &block) if matching_expectation
+          message = UnexpectedInvocation.new(self, symbol, *arguments).to_s
+          require 'mocha/mockery'
+          message << Mockery.instance.mocha_inspect
+          raise ExpectationError.new(message, caller)
+        end
+      end
+    end
+
+  end
+
+  class Call
+
+    attr_reader :blocks
+
+    def initialize(*blocks)
+      @blocks = [ *blocks ]
+    end
+
+    def next(arguments, &block)
+      case @blocks.length
+        when 0 then nil
+        when 1 then @blocks.first.call(*arguments, &block)
+        else @blocks.shift.call(*arguments, &block)
+      end
+    end
+
+    def +(other)
+      self.class.new(*(@blocks + other.blocks))
+    end
+
+  end
+end

data/test/support/processor.rb

@@ -0,0 +1,7 @@
+class Debugger::Processor
+  class << self
+    def print(message)
+      Debugger.handler.interface.print_queue << message
+    end
+  end
+end

data/test/support/test_dsl.rb

@@ -0,0 +1,205 @@
+module TestDsl
+  module Shared
+    def fullpath(filename)
+      (Pathname.new(__FILE__) + "../../examples/#{filename}.rb").cleanpath.to_s
+    end
+  end
+  include Shared
+
+  def self.included(base)
+    base.class_eval do
+      extend ClassMethods
+      before do
+        Debugger.interface = TestInterface.new
+        Debugger.handler.display.clear
+      end
+      after do
+        Debugger.handler.display.clear
+      end
+    end
+  end
+
+  # Adds commands to the input queue, so they will be retrieved by Processor later.
+  # I.e. it emulates user's input.
+  #
+  # If a command is a Proc object, it will be executed before retrieving by Processor.
+  # May be handy when you need build a command depending on the current context/state.
+  #
+  # Usage:
+  #
+  #   enter 'b 12'
+  #   enter 'b 12', 'cont'
+  #   enter ['b 12', 'cont']
+  #   enter 'b 12', ->{"disable #{breakpoint.id}"}, 'cont'
+  #
+  def enter(*messages)
+    messages = messages.first.is_a?(Array) ? messages.first : messages
+    interface.input_queue.concat(messages)
+  end
+
+  # Runs a debugger with the provided basename for a file. The file should be placed
+  # to the test/new/examples dir.
+  #
+  # You also can specify block, which will be executed when Processor extracts all the
+  # commands from the input queue. You can use it e.g. for making asserts for the current
+  # test. If you specified the block, and it never was executed, the test will fail.
+  #
+  # Usage:
+  #
+  #   debug "ex1" # ex1 should be placed in test/new/examples/ex1.rb
+  #
+  #   enter 'b 4', 'cont'
+  #   debug("ex1") { state.line.must_equal 4 } # It will be executed after running 'cont' and stopping at the breakpoint
+  #
+  def debug_file(filename, &block)
+    is_test_block_called = false
+    debug_completed = false
+    exception = nil
+    Debugger.stubs(:run_init_script)
+    if block
+      interface.test_block = lambda do
+        is_test_block_called = true
+        # We need to store exception and reraise it after completing debugging, because
+        # Debugger will swallow any exceptions, so e.g. our failed assertions will be ignored
+        begin
+          block.call
+        rescue Exception => e
+          exception = e
+          raise e
+        end
+      end
+    end
+    Debugger.start do
+      load fullpath(filename)
+      debug_completed = true
+    end
+    flunk "Debug block was not completed" unless debug_completed
+    flunk "test block is provided, but not called" if block && !is_test_block_called
+    raise exception if exception
+  end
+
+  # Checks the output of the debugger. By default it checks output queue of the current interface,
+  # but you can check again any queue by providing it as a second argument.
+  #
+  # Usage:
+  #
+  #   enter 'break 4', 'cont'
+  #   debug("ex1")
+  #   check_output "Breakpoint 1 at #{fullpath('ex1')}:4"
+  #
+  def check_output(check_method, *args)
+    queue = args.last.is_a?(String) || args.last.is_a?(Regexp) ? interface.output_queue : args.pop
+    queue_messages = queue.map(&:strip)
+    messages = Array(args).map { |msg| msg.is_a?(String) ? msg.strip : msg }
+    queue_messages.send(check_method, messages)
+  end
+
+  def check_output_includes(*args)
+    check_output :must_include_in_order, *args
+  end
+
+  def check_output_doesnt_include(*args)
+    check_output :wont_include_in_order, *args
+  end
+
+  def interface
+    Debugger.handler.interface
+  end
+
+  def state
+    $rdebug_state
+  end
+
+  def context
+    state.context
+  end
+
+  def breakpoint
+    Debugger.breakpoints.first
+  end
+
+  def force_set_const(klass, const, value)
+    klass.send(:remove_const, const) if klass.const_defined?(const)
+    klass.const_set(const, value)
+  end
+
+  def change_line_in_file(file, line, new_line_content)
+    old_content = File.read(file)
+    new_content = old_content.split("\n").tap { |c| c[line - 1] = new_line_content }.join("\n")
+    File.open(file, 'w') { |f| f.write(new_content) }
+  end
+
+  def temporary_change_method_value(item, method, value)
+    old = item.send(method)
+    item.send("#{method}=", value)
+    yield
+  ensure
+    item.send("#{method}=", old)
+  end
+
+  def temporary_change_hash_value(item, key, value)
+    old_value = item[key]
+    begin
+      item[key] = value
+      yield
+    ensure
+      item[key] = old_value
+    end
+  end
+
+  def temporary_set_const(klass, const, value)
+    old_value = klass.const_defined?(const) ? klass.const_get(const) : :__undefined__
+    begin
+      force_set_const(klass, const, value)
+      yield
+    ensure
+      if old_value == :__undefined__
+        klass.send(:remove_const, const)
+      else
+        force_set_const(klass, const, old_value)
+      end
+    end
+  end
+
+  module ClassMethods
+    include Shared
+
+    def temporary_change_method_value(item, method, value)
+      old_value = nil
+      before do
+        old_value = item.send(method)
+        item.send("#{method}=", value)
+      end
+      after do
+        item.send("#{method}=", old_value)
+      end
+    end
+
+    def temporary_change_hash_value(item, key, value)
+      old_value = nil
+      before do
+        old_value = item[key]
+        item[key] = value
+      end
+      after do
+        item[key] = old_value
+      end
+    end
+
+    def temporary_set_const(klass, const, value)
+      old_value = nil
+      before do
+        old_value = klass.const_defined?(const) ? klass.const_get(const) : :__undefined__
+        force_set_const(klass, const, value)
+      end
+      after do
+        if old_value == :__undefined__
+          klass.send(:remove_const, const)
+        else
+          force_set_const(klass, const, old_value)
+        end
+      end
+    end
+  end
+
+end