11

I'm trying to unit test a piece of code that I've written in Ruby that calls File.open. To mock it out, I monkeypatched File.open to the following:

class File
  def self.open(name, &block)
    if name.include?("retval")
      return "0\n"
    else
      return "1\n"
    end
  end
end

The problem is that I'm using rcov to run this whole thing since it uses File.open to write code coverage information, it gets the monkeypatched version instead of the real one. How can I un-monkeypatch this method to revert it to it's original method? I've tried messing around with alias, but to no avail so far.

Chris Bunch
  • 87,773
  • 37
  • 126
  • 127

5 Answers5

19

Expanding on @Tilo's answer, use alias again to undo the monkey patching.

Example:

# Original definition
class Foo
  def one()
    1
  end
end

foo = Foo.new
foo.one

# Monkey patch to 2
class Foo
  alias old_one one
  def one()
    2
  end
end

foo.one

# Revert monkey patch
class Foo
  alias one old_one
end

foo.one
peakxu
  • 6,667
  • 1
  • 28
  • 27
  • So this doesn't work with rcov (it still sees only the old method), but since the question was really 'just un-monkey patch a method', this answers it the best. Thanks! – Chris Bunch Oct 26 '11 at 00:35
3

or you can use a stubbing framework (like rspec or mocha) and stub the File.Open method.

File.stub(:open => "0\n")

Dan
  • 1,396
  • 1
  • 10
  • 21
  • I definitely could (I previously was using shoulda) but was looking to use vanilla-Ruby to get this job done. – Chris Bunch Oct 25 '11 at 18:01
  • @ChrisBunch In terms of being practical, this is really the correct solution. You shouldn't be monkey-patching something as fundamental as opening files. If you're not trying to be practical, are you just being curious? No problem with that, but I think others would appreciate knowing that up-front. – Kelvin Sep 28 '12 at 17:58
2

File is just a constant that holds an instance of Class. You could set it to a temporary class that responds to open, and then restore the original one:

original_file = File
begin
  File = Class.new             # warning: already initialized constant File
  def File.open(name, &block)
    # Implement method
  end
  # Run test
ensure
  File = original_file         # warning: already initialized constant File
end
Matheus Moreira
  • 17,106
  • 3
  • 68
  • 107
  • That doesn't seem to work within Test/Unit - it complains that I'm redefining constants (File), and that isn't ok within methods (only at the top-level, which precludes me using Test/Unit). – Chris Bunch Oct 25 '11 at 18:02
2

you can simply alias it like this:

alias new_name old_name

e.g.:

class File
  alias old_open open

  def open
    ...
  end
end

now you can still access the original File.open method via File.old_open

Alternatively, you could try something like this:

ruby - override method and then revert

http://blog.jayfields.com/2006/12/ruby-alias-method-alternative.html

Community
  • 1
  • 1
Tilo
  • 33,354
  • 5
  • 79
  • 106
  • This is very close to what I want, but I can't modify rcov, so I can't tell it to use `File.old_open`. I thus want to revert `old_open` to `open` once my test is done so that rcov picks it up without me having to modify it. – Chris Bunch Oct 25 '11 at 18:51
  • I see... please check the pointers at the bottom of my answer – Tilo Oct 25 '11 at 19:08
  • That helped a lot - thanks! It still doesn't work with rcov so I had to work around it a different way, but the links help a lot for the future. – Chris Bunch Oct 26 '11 at 00:36
1

The correct way to do this is to actually use a stubbing framework like Dan says.

For example, in rspec, you'd do:

it "reads the file contents" do
  File.should_receive(:open) {|name|
    if name.include?("retval")
      "0\n"
    else
      "1\n"
    end
  }
  File.open("foo retval").should == "0\n"
  File.open("other file").should == "1\n"
end

But for the curious, here's a semi-safe way to do it without external libs. The idea is to isolate the stub so as little code is affected by it as possible.

I named this script isolated-patch.rb:

class File
  class << self
    alias_method :orig_open, :open

    def stubbed_open(name, &block)
      if name.include?("retval")
        return "0\n"
      else
        return "1\n"
      end
    end
  end
end


def get_size(path)
  # contrived example
  File.open(path) {|fh|
    # change bytesize to size on ruby 1.8
    fh.read.bytesize
  }
end

# The stub will apply for the duration of the block.
# That means the block shouldn't be calling any methods where file opening
#   needs to work normally.
# Warning: not thread-safe
def stub_file_open
  class << File
    alias_method :open, :stubbed_open
  end
  yield
ensure
  class << File
    alias_method :open, :orig_open
  end
end

if __FILE__ == $0
  stub_file_open do
    val = File.open("what-retval") { puts "this is not run" }
    puts "stubbed open() returned: #{val.inspect}"
    size = get_size("test.txt")
    puts "obviously wrong size of test.txt: #{size.inspect}"
  end

  # you need to manually create this file before running the script
  size = get_size("test.txt")
  puts "size of test.txt: #{size.inspect}"
end

Demo:

> echo 'foo bar' > test.txt
> ruby isolated-patch.rb
stubbed open() returned: "0\n"
obviously wrong size of test.txt: "1\n"
size of test.txt: 8
Kelvin
  • 20,119
  • 3
  • 60
  • 68