Redefine a class constant

[fguillen]

I would like to mock a class constant but it does not work:

require 'test/unit'
require 'mocha'

class A
  MY_CONST = 'a'
end

class MyTest < Test::Unit::TestCase
  def test_should_returns_b
    assert_equal( 'a', A::MY_CONST )
    A.stubs( :MY_CONST ).returns( 'b' )
    assert_equal( 'b', A::MY_CONST )
  end
end

Is there any way to do something like this?

Thanks.

f.

[floehopper]

Mocha is only designed to work with methods, not constants.

I can think of at least 3 options :-

1. Update the referenced String in-place (constants are only constant references)

   def test_should_returns_b
     assert_equal('a', A::MY_CONST)
     A::MY_CONST.gsub!(/a/, 'b')
     assert_equal('b', A::MY_CONST)
   end
   

2. Remove and set the constant on the class (removal avoids a warning when setting) :-

   def test_should_returns_b
     assert_equal('a', A::MY_CONST)
     A.send(:remove_const, :MY_CONST)
     A.const_set(:MY_CONST, 'b')
     assert_equal('b', A::MY_CONST)
   end
   

3. Wrap the constant in a method (if it changes in a test, is it really a constant?) :-

   class A
     MY_CONST = 'a'
     def self.my_const; MY_CONST; end
   end
   
   class MyTest < Test::Unit::TestCase
     def test_should_returns_b
       assert_equal('a', A.my_const)
       A.stubs(:my_const).returns('b')
       assert_equal('b', A.my_const)
     end
   end
   

You might also want to consider whether you need to stub the constant at all. It might be sufficient (and more intention revealing) to reference the constant in your tests.

I hope that helps. Please close this issue if you are happy with the response.

[fguillen]

The options 1 and 2 are changing the behavior for class A for the next tests, aren't they?

Option 3 works very well but this forces to me (and every one in the team) to change every access to this constant and using the wrapper method instead of the direct access to the constant. What we can say it is an intrusive test.

I have done something like this:

require 'test/unit'
require 'mocha'

class A
  MY_CONST = 'a'
end

class MyTest < Test::Unit::TestCase
  def setup
    @old_constant = A::MY_CONST
    A.const_set( :MY_CONST, 'b' )
  end

  def teardown
    A.const_set( :MY_CONST, @old_constant )
  end

  def test_should_returns_b
    assert_equal( 'b', A::MY_CONST )
  end
end

There are a couple of warnings that with the Rails silence_warnings you can hidden them.

Anyhow I still think that would be great if Mocha will offer to us the possibility of mocking a constant so we will can play with them on an easy way.

The points are, is this possible? do you think is a good idea to add this behavior to Mocha?. If both answers are yes I can try to help in this feature. If any answer is not you can close the issue :)

Regards.

[floehopper]

You are right about options 1 & 2 - my examples were just demonstrating what was possible - they don't return the constant to its initial state, but hopefully you can see this would be trivial to implement. I understand your reservations about option 3, but I'm not sure I completely agree - I'm always happy to change my application code to make testing easier.

Anyway, just to be clear, it certainly is possible to do what you want to do. However, just because something is possible, doesn't mean it's desirable!

Personally, I don't find I need to stub constants when writing tests, so it would be good to understand more about why you want to be able to do it. Can you give us a more real-world example? It's always easier to talk about something more concrete.

If it makes any sense for the value to change for the duration of a test, I would be inclined to store it in some kind of variable instead of a constant, but perhaps use a constant for the variable's default value.

Anyway, if you'd like to discuss this further and see if other people are interested in this feature, please drop us a line on the mailing list.

Cheers, James.

[fguillen]

Probably hasn't too much sense what I'm proposing.

Thanks @floehopper for your answers.

[mariusbutuc]

Still comes up high in google searches so FWIW here are my ¢2: wrap the constant in a class method

class Fetcher
  DATA_FILE = 'tmp/real_data.csv'.freeze
  # …
  def self.data_file
    DATA_FILE
  end
end

that we can later stub in the test:

class FetcherTest < ActiveSupport::TestCase
  def setup
    Fetcher.stubs(:data_file).returns('test/fixtures/files/test_data.csv')
  end
  # …
end

[grosser]

see below for better version

  def stub_const(const, value)
    old = A.const_get(const)
    A.send(:remove_const, const)
    A.const_set(const, value)
    yield
  ensure
    A.send(:remove_const, const)
    A.const_set(const, old)
  end

[floehopper]

@grosser Do you mind me asking what prompted your comment on this issue? Are you suggesting that this functionality should be included in Mocha?

[grosser]

not sure ... just came here and did not find a nice solution so I left the one I'm using now for future wanderers :)

[floehopper]

ok - thanks!