Ruby在Rspec中检查vs to_s

Question

Consider the following test for rspec :

class RspecTest
  def initialize
  end

  def to_s
    "foo"
  end
end

describe RspecTest do
  it "should return foo (to_s)" do
    RspecTest.new.should == "foo"
  end

  it "should return foo (inspect)" do
    RspecTest.new.inspect == "foo"
  end
end

And when tested through rspec :

%: rspec rspec_test.rb 
F.

Failures:

  1) RspecTest should return foo (to_s)
     Failure/Error: RspecTest.new.should == "foo"
       expected: "foo"
            got: foo (using ==)
       Diff:
     # ./rspec_test.rb:13:in `block (2 levels) in <top (required)>'

Finished in 0.00059 seconds
2 examples, 1 failure

So the first test fails, whereas the second test passes. Why is that?

Answer 1

The second test passes, because it doesn't test anything. It doesn't contain any expectation (ie a call to should or should_not ). It cannot fail, because there is nothing to fail.

The first test fails, because you are asserting that an instance of RspecTest is equal to the string 'foo' . This cannot possibly be true. How could those two objects possibly be equal if they aren't even the same kind of object?

Judging by the description of the test, you didn't actually mean to test whether the instance of RspecTest is equal to the string 'foo' , but rather whether the return value of the instance method to_s is equal to the string 'foo' . However, you never call to_s anywhere.

Let's first fix the two obvious problems. Now, we have a test like this:

it 'should return foo (to_s)' do
  RspecTest.new.to_s.should == 'foo'
end

it 'should return foo (inspect)' do
  RspecTest.new.inspect.should == 'foo'
end

There is some unnecessary duplication there with the two RspecTest.new calls, so let's fix that by simply making RspecTest.new the default subject:

  subject { RspecTest.new }

  it 'should return foo (to_s)' do
    subject.to_s.should == 'foo'
  end

  it 'should return foo (inspect)' do
    subject.inspect.should == 'foo'
  end

And actually, if you don't supply an explicit subject, then RSpec will walk up the chain of nested describe blocks until it finds a class, and will simply call that class's new method to provide the subject. So, we can just delete the subject declaration:

  it 'should return foo (to_s)' do
    subject.to_s.should == 'foo'
  end

  it 'should return foo (inspect)' do
    subject.inspect.should == 'foo'
  end

Personally, I prefer to let RSpec provide the example name by itself, so that the example name and the actual example code don't get out of sync, so I'd probably write that more like this:

describe RspecTest do
  describe '#to_s' do
    it { subject.to_s.should == 'foo' }
  end

  describe '#inspect' do
    it { subject.inspect.should == "foo" }
  end
end

Which yields:

RspecTest
  #to_s
    should == "foo"
  #inspect
    should == "foo"

Finished in 0.16023 seconds
2 examples, 0 failures

Last but not least, your initializer isn't actually doing anything, so you don't need it. All together, my version looks like this:

class RspecTest
  def to_s; 'foo' end
end

describe RspecTest do
  describe '#to_s' do
    it { subject.to_s.should == 'foo' }
  end

  describe '#inspect' do
    it { subject.inspect.should == "foo" }
  end
end

Answer 2

I think your test should be the following (and they'll both pass). The first one is missing the actual to_s call, and the seocnd one is missing the .should :

describe RspecTest do
  it "should return foo (to_s)" do
    RspecTest.new.to_s.should == "foo"
  end

  it "should return foo (inspect)" do
    RspecTest.new.inspect.should == "foo"
  end
end