Question

When using RSpec to test deeply nested data structures, I find the need to define subjects in nested contexts in terms of the subjects in the containing contexts. I have looked extensively but not found any examples on how to do with without defining many variables. It complicates the specs and limits the possibility of spec reuse. I am curious whether there is a way to do this in RSpec as it stands and, if not, what would be a good way to approach the problem.

Right now, my code looks something like:

context 'with a result which is a Hash' do
  before do
    @result = get_result()
  end
  subject { @result }
  it { should be_a Hash }
  context 'with an Array' do
    before do
      @array_elem = @result[special_key]
    end
    subject { @array_elem }
    it { should be_an Array }
    context 'that contains a Hash' do
      before do
        @nested_hash = ...
      end
      subject { @nested_hash }
      ...
    end
  end
end

Instead, I’d rather write something along the lines of:

context 'with a result which is a Hash' do
  subject { get_result }
  it { should be_a Hash }
  context 'with an Array' do
    subject { parent_subject[special_key] }
    it { should be_an Array }
    context 'that contains a Hash' do
      subject { do_something_with(parent_subject) }
      ...
    end
  end
end

What’s a way to extend RSpec with this type of automatic subject hierarchy management?

Answer 1

In this type of hierarchic structure, I would actually drop the use of subject and make the subject explicit. While this could result in a bit more typing (if you have a lot of tests), it is also clearer.
The nested subject-statements could also be confusing what is actually being tested if you are three levels down.

  context 'with a result which is a Hash' do
    before do
      @result = get_result()
    end
    it { @result.should be_a Hash }
    context 'special_key' do
      before do
        @array_elem = @result[special_key]
      end
      it { @array_elem.should be_an Array }
      context 'that contains a Hash' do
        before do
          @nested_hash = ...
        end
        it { @nested_hash.should be_a Hash }
        ...
      end
    end
  end

But this could be a matter of taste.
Hope this helps.