Back to Repositories

Testing InheritableValues Utility Implementation in ruby-grape/grape

This test suite validates the InheritableValues utility class in Grape, focusing on value inheritance, manipulation, and cloning behavior. The tests ensure proper handling of key-value operations while maintaining parent-child relationships in the inheritance chain.

Test Coverage Overview

The test suite provides comprehensive coverage of the InheritableValues class functionality:

Key-value operations (get, set, delete)
Parent-child value inheritance behavior
Hash representation conversion
Object cloning with complex data types

Implementation Analysis

The testing approach uses RSpec’s described_class pattern with nested describe blocks for organized test grouping. Tests leverage let statements for setup and context blocks for different scenarios, particularly around complex data type handling.

The implementation focuses on verifying both direct value operations and inheritance behavior through parent-child relationships.

Technical Details

Testing tools and setup:

RSpec as the testing framework
Double mocking for complex object simulation
Subject/let blocks for test state management
Frozen string literal pragma for optimization

Best Practices Demonstrated

The test suite exemplifies several testing best practices:

Clear test organization with descriptive contexts
Isolated test cases with proper setup
Edge case coverage for inheritance scenarios
Proper mocking of complex objects
Consistent assertion patterns

ruby-grape/grape

spec/grape/util/inheritable_values_spec.rb

            
# frozen_string_literal: true

describe Grape::Util::InheritableValues do
  subject { described_class.new(parent) }

  let(:parent) { described_class.new }

  describe '#delete' do
    it 'deletes a key' do
      subject[:some_thing] = :new_foo_bar
      subject.delete :some_thing
      expect(subject[:some_thing]).to be_nil
    end

    it 'does not delete parent values' do
      parent[:some_thing] = :foo
      subject[:some_thing] = :new_foo_bar
      subject.delete :some_thing
      expect(subject[:some_thing]).to eq :foo
    end
  end

  describe '#[]' do
    it 'returns a value' do
      subject[:some_thing] = :foo
      expect(subject[:some_thing]).to eq :foo
    end

    it 'returns parent value when no value is set' do
      parent[:some_thing] = :foo
      expect(subject[:some_thing]).to eq :foo
    end

    it 'overwrites parent value with the current one' do
      parent[:some_thing] = :foo
      subject[:some_thing] = :foo_bar
      expect(subject[:some_thing]).to eq :foo_bar
    end

    it 'parent values are not changed' do
      parent[:some_thing] = :foo
      subject[:some_thing] = :foo_bar
      expect(parent[:some_thing]).to eq :foo
    end
  end

  describe '#[]=' do
    it 'sets a value' do
      subject[:some_thing] = :foo
      expect(subject[:some_thing]).to eq :foo
    end
  end

  describe '#to_hash' do
    it 'returns a Hash representation' do
      parent[:some_thing] = :foo
      subject[:some_thing_more] = :foo_bar
      expect(subject.to_hash).to eq(some_thing: :foo, some_thing_more: :foo_bar)
    end
  end

  describe '#clone' do
    let(:obj_cloned) { subject.clone }

    context 'complex (i.e. not primitive) data types (ex. entity classes, please see bug #891)' do
      let(:description) { { entity: double } }

      before { subject[:description] = description }

      it 'copies values; does not duplicate them' do
        expect(obj_cloned[:description]).to eq description
      end
    end
  end
end