ruby--ruby/spec/ruby/language/ensure_spec.rb

require_relative '../spec_helper'
require_relative 'fixtures/ensure'

describe "An ensure block inside a begin block" do
  before :each do
    ScratchPad.record []
  end

  it "is executed when an exception is raised in it's corresponding begin block" do
    lambda {
      begin
        ScratchPad << :begin
        raise EnsureSpec::Error
      ensure
        ScratchPad << :ensure
      end
    }.should raise_error(EnsureSpec::Error)

    ScratchPad.recorded.should == [:begin, :ensure]
  end

  it "is executed when an exception is raised and rescued in it's corresponding begin block" do
    begin
      ScratchPad << :begin
      raise "An exception occurred!"
    rescue
      ScratchPad << :rescue
    ensure
      ScratchPad << :ensure
    end

    ScratchPad.recorded.should == [:begin, :rescue, :ensure]
  end

  it "is executed even when a symbol is thrown in it's corresponding begin block" do
    catch(:symbol) do
      begin
        ScratchPad << :begin
        throw(:symbol)
      rescue
        ScratchPad << :rescue
      ensure
        ScratchPad << :ensure
      end
    end

    ScratchPad.recorded.should == [:begin, :ensure]
  end

  it "is executed when nothing is raised or thrown in it's corresponding begin block" do
    begin
      ScratchPad << :begin
    rescue
      ScratchPad << :rescue
    ensure
      ScratchPad << :ensure
    end

    ScratchPad.recorded.should == [:begin, :ensure]
  end

  it "has no return value" do
    begin
      :begin
    ensure
      :ensure
    end.should == :begin
  end

  it "sets exception cause if raises exception in block and in ensure" do
    -> {
      begin
        raise "from block"
      ensure
        raise "from ensure"
      end
    }.should raise_error(RuntimeError, "from ensure") do |e|
      e.cause.message.should == "from block"
    end
  end
end

describe "The value of an ensure expression," do
  it "in no-exception scenarios, is the value of the last statement of the protected body" do
    begin
      v = 1
      eval('x=1') # to prevent opts from triggering
      v
    ensure
      v = 2
    end.should == 1
  end

  it "when an exception is rescued, is the value of the rescuing block" do
    begin
      raise 'foo'
    rescue
      v = 3
    ensure
      v = 2
    end.should == 3
  end
end

describe "An ensure block inside a method" do
  before :each do
    @obj = EnsureSpec::Container.new
  end

  it "is executed when an exception is raised in the method" do
    lambda { @obj.raise_in_method_with_ensure }.should raise_error(EnsureSpec::Error)
    @obj.executed.should == [:method, :ensure]
  end

  it "is executed when an exception is raised and rescued in the method" do
    @obj.raise_and_rescue_in_method_with_ensure
    @obj.executed.should == [:method, :rescue, :ensure]
  end

  it "is executed even when a symbol is thrown in the method" do
    catch(:symbol) { @obj.throw_in_method_with_ensure }
    @obj.executed.should == [:method, :ensure]
  end

  it "has no impact on the method's implicit return value" do
    @obj.implicit_return_in_method_with_ensure.should == :method
  end

  it "has an impact on the method's explicit return value" do
    @obj.explicit_return_in_method_with_ensure.should == :ensure
  end

  it "has an impact on the method's explicit return value from rescue if returns explicitly" do
    @obj.explicit_return_in_rescue_and_explicit_return_in_ensure.should == "returned in ensure"
  end

  it "has no impact on the method's explicit return value from rescue if returns implicitly" do
    @obj.explicit_return_in_rescue_and_implicit_return_in_ensure.should == "returned in rescue"
  end

  it "suppresses exception raised in method if returns value explicitly" do
    @obj.raise_and_explicit_return_in_ensure.should == "returned in ensure"
  end

  it "suppresses exception raised in rescue if returns value explicitly" do
    @obj.raise_in_rescue_and_explicit_return_in_ensure.should == "returned in ensure"
  end

  it "overrides exception raised in rescue if raises exception itself" do
    -> {
      @obj.raise_in_rescue_and_raise_in_ensure
    }.should raise_error(RuntimeError, "raised in ensure")
  end

  it "suppresses exception raised in method if raises exception itself" do
    -> {
      @obj.raise_in_method_and_raise_in_ensure
    }.should raise_error(RuntimeError, "raised in ensure")
  end
end

describe "An ensure block inside a class" do
  before :each do
    ScratchPad.record []
  end

  it "is executed when an exception is raised" do
    lambda {
      eval <<-ruby
        class EnsureInClassExample
          ScratchPad << :class
          raise EnsureSpec::Error
        ensure
          ScratchPad << :ensure
        end
      ruby
    }.should raise_error(EnsureSpec::Error)

    ScratchPad.recorded.should == [:class, :ensure]
  end

  it "is executed when an exception is raised and rescued" do
    eval <<-ruby
      class EnsureInClassExample
        ScratchPad << :class
        raise
      rescue
        ScratchPad << :rescue
      ensure
        ScratchPad << :ensure
      end
    ruby

    ScratchPad.recorded.should == [:class, :rescue, :ensure]
  end

  it "is executed even when a symbol is thrown" do
    catch(:symbol) do
      eval <<-ruby
        class EnsureInClassExample
          ScratchPad << :class
          throw(:symbol)
        rescue
          ScratchPad << :rescue
        ensure
          ScratchPad << :ensure
        end
      ruby
    end

    ScratchPad.recorded.should == [:class, :ensure]
  end

  it "is executed when nothing is raised or thrown" do
    eval <<-ruby
      class EnsureInClassExample
        ScratchPad << :class
      rescue
        ScratchPad << :rescue
      ensure
        ScratchPad << :ensure
      end
    ruby

    ScratchPad.recorded.should == [:class, :ensure]
  end

  it "has no return value" do
    result = eval <<-ruby
      class EnsureInClassExample
        :class
      ensure
        :ensure
      end
    ruby

    result.should == :class
  end
end

describe "An ensure block inside {} block" do
  it "is not allowed" do
    lambda {
      eval <<-ruby
        lambda {
          raise
        ensure
        }
      ruby
    }.should raise_error(SyntaxError)
  end
end

ruby_version_is "2.5" do
  describe "An ensure block inside 'do end' block" do
    before :each do
      ScratchPad.record []
    end

    it "is executed when an exception is raised in it's corresponding begin block" do
      lambda {
        eval(<<-ruby).call
          lambda do
            ScratchPad << :begin
            raise EnsureSpec::Error
          ensure
            ScratchPad << :ensure
          end
        ruby
      }.should raise_error(EnsureSpec::Error)

      ScratchPad.recorded.should == [:begin, :ensure]
    end

    it "is executed when an exception is raised and rescued in it's corresponding begin block" do
      eval(<<-ruby).call
        lambda do
          ScratchPad << :begin
          raise "An exception occurred!"
        rescue
          ScratchPad << :rescue
        ensure
          ScratchPad << :ensure
        end
      ruby

      ScratchPad.recorded.should == [:begin, :rescue, :ensure]
    end

    it "is executed even when a symbol is thrown in it's corresponding begin block" do
      catch(:symbol) do
        eval(<<-ruby).call
          lambda do
            ScratchPad << :begin
            throw(:symbol)
          rescue
            ScratchPad << :rescue
          ensure
            ScratchPad << :ensure
          end
        ruby
      end

      ScratchPad.recorded.should == [:begin, :ensure]
    end

    it "is executed when nothing is raised or thrown in it's corresponding begin block" do
      eval(<<-ruby).call
        lambda do
          ScratchPad << :begin
        rescue
          ScratchPad << :rescue
        ensure
          ScratchPad << :ensure
        end
      ruby

      ScratchPad.recorded.should == [:begin, :ensure]
    end

    it "has no return value" do
      result = eval(<<-ruby).call
        lambda do
          :begin
        ensure
          :ensure
        end
      ruby

      result.should == :begin
    end
  end
end