Module: Cuprum::Collections::RSpec::Contracts::AssociationContracts::ShouldBeAHasAssociationContract

Extended by:

RSpec::SleepingKingStudios::Contract

Defined in:

lib/cuprum/collections/rspec/contracts/association_contracts.rb

Overview

Contract validating the behavior of a HasAssociation.

Instance Method Summary

• #apply(example_group) ⇒ Object

  Adds the contract to the example group.

Instance Method Details

#apply(example_group) ⇒ Object

Adds the contract to the example group.

Parameters:

• example_group (RSpec::Core::ExampleGroup) —

  the example group to which the contract is applied.

# File 'lib/cuprum/collections/rspec/contracts/association_contracts.rb', line 1166

contract do
  include Cuprum::Collections::RSpec::Contracts::RelationContracts

  include_contract 'should be an association'

  describe '#build_entities_query' do
    let(:key)      { subject.primary_key_name }
    let(:entities) { [] }
    let(:options)  { {} }
    let(:query) do
      association.build_entities_query(*entities, **options)
    end
    let(:evaluated) do
      Spec::QueryBuilder.new.instance_exec(&query)
    end

    example_class 'Spec::Entity' do |klass|
      klass.define_method(:initialize) do |**attributes|
        attributes.each do |key, value|
          instance_variable_set(:"@#{key}", value)
        end
      end

      klass.attr_reader :id
    end

    example_class 'Spec::QueryBuilder' do |klass|
      klass.define_method(:one_of) { |values| { 'one_of' => values } }
    end

    context 'when the foreign key name is blank' do
      let(:error_message) do
        "foreign key name can't be blank"
      end

      it 'should raise an exception' do
        expect { association.build_entities_query(*entities) }
          .to raise_error ArgumentError, error_message
      end
    end

    context 'when initialized with foreign_key_name: value' do
      let(:foreign_key_name) { 'author_id' }
      let(:constructor_options) do
        super().merge(foreign_key_name: foreign_key_name)
      end

      describe 'with no entities' do
        let(:entities) { [] }

        it { expect(query).to be_a Proc }

        it { expect(evaluated).to be == {} }
      end

      describe 'with one nil entity' do
        let(:entities) { [nil] }

        it { expect(evaluated).to be == {} }
      end

      describe 'with one invalid entity' do
        let(:entities) { [Object.new.freeze] }
        let(:error_message) do
          "undefined method :[] or :#{key} for #{entities.first.inspect}"
        end

        it 'should raise an exception' do
          expect { association.build_entities_query(*entities) }
            .to raise_error ArgumentError, error_message
        end
      end

      describe 'with one entity that responds to #[] and key: nil' do
        let(:entities) { [{ key => nil }] }

        it { expect(evaluated).to be == {} }

        describe 'with allow_nil: true' do
          let(:options) { super().merge(allow_nil: true) }

          it { expect(evaluated).to be == { 'author_id' => nil } }
        end
      end

      describe 'with one entity that responds to #[] and key: value' do
        let(:entities) { [{ key => 0 }] }

        it { expect(evaluated).to be == { 'author_id' => 0 } }
      end

      describe 'with one entity that responds to #id and key: nil' do
        let(:entities) { [Spec::Entity.new(key => nil)] }

        it { expect(evaluated).to be == {} }

        describe 'with allow_nil: true' do
          let(:options) { super().merge(allow_nil: true) }

          it { expect(evaluated).to be == { 'author_id' => nil } }
        end
      end

      describe 'with one entity that responds to #id and key: value' do
        let(:entities) { [Spec::Entity.new(key => 0)] }

        it { expect(evaluated).to be == { 'author_id' => 0 } }
      end

      describe 'with multiple entities' do
        let(:entities) do
          [
            Spec::Entity.new(key => 0),
            Spec::Entity.new(key => 1),
            Spec::Entity.new(key => 2)
          ]
        end
        let(:expected) do
          { 'author_id' => { 'one_of' => [0, 1, 2] } }
        end

        it { expect(evaluated).to be == expected }
      end

      describe 'with multiple entities including nil' do
        let(:entities) do
          [
            Spec::Entity.new(key => 0),
            nil,
            Spec::Entity.new(key => 1),
            nil,
            Spec::Entity.new(key => 2)
          ]
        end
        let(:expected) do
          { 'author_id' => { 'one_of' => [0, 1, 2] } }
        end

        it { expect(evaluated).to be == expected }
      end

      describe 'with multiple entities including nil ids' do
        let(:entities) do
          [
            Spec::Entity.new(key => 0),
            Spec::Entity.new(key => nil),
            Spec::Entity.new(key => 1),
            Spec::Entity.new(key => nil),
            Spec::Entity.new(key => 2)
          ]
        end
        let(:expected) do
          { 'author_id' => { 'one_of' => [0, 1, 2] } }
        end

        it { expect(evaluated).to be == expected }

        describe 'with allow_nil: true' do
          let(:options) { super().merge(allow_nil: true) }
          let(:expected) do
            { 'author_id' => { 'one_of' => [0, nil, 1, 2] } }
          end

          it { expect(evaluated).to be == expected }
        end
      end

      describe 'with multiple entities including duplicate ids' do
        let(:entities) do
          [
            Spec::Entity.new(key => 0),
            Spec::Entity.new(key => 1),
            Spec::Entity.new(key => 0),
            Spec::Entity.new(key => 1),
            Spec::Entity.new(key => 2)
          ]
        end
        let(:expected) do
          { 'author_id' => { 'one_of' => [0, 1, 2] } }
        end

        it { expect(evaluated).to be == expected }

        describe 'with deduplicate: false' do
          let(:options) { super().merge(deduplicate: false) }
          let(:expected) do
            { 'author_id' => { 'one_of' => [0, 1, 0, 1, 2] } }
          end

          it { expect(evaluated).to be == expected }
        end
      end
    end
  end

  describe '#build_keys_query' do
    let(:keys)    { [] }
    let(:options) { {} }
    let(:query) do
      association.build_keys_query(*keys, **options)
    end
    let(:evaluated) do
      Spec::QueryBuilder.new.instance_exec(&query)
    end

    example_class 'Spec::QueryBuilder' do |klass|
      klass.define_method(:one_of) { |values| { 'one_of' => values } }
    end

    context 'when the foreign key name is blank' do
      let(:error_message) do
        "foreign key name can't be blank"
      end

      it 'should raise an exception' do
        expect { association.build_keys_query(*keys) }
          .to raise_error ArgumentError, error_message
      end
    end

    context 'when initialized with foreign_key_name: value' do
      let(:foreign_key_name) { 'author_id' }
      let(:constructor_options) do
        super().merge(foreign_key_name: foreign_key_name)
      end

      describe 'with no keys' do
        let(:keys) { [] }

        it { expect(query).to be_a Proc }

        it { expect(evaluated).to be == {} }
      end

      describe 'with one nil key' do
        let(:keys) { [nil] }

        it { expect(evaluated).to be == {} }

        describe 'with allow_nil: true' do
          let(:options) { { allow_nil: true } }

          it { expect(evaluated).to be == { 'author_id' => nil } }
        end
      end

      describe 'with one non-nil key' do
        let(:keys) { [0] }

        it { expect(evaluated).to be == { 'author_id' => 0 } }
      end

      describe 'with many keys' do
        let(:keys)     { [0, 1, 2] }
        let(:expected) { { 'author_id' => { 'one_of' => keys } } }

        it { expect(evaluated).to be == expected }
      end

      describe 'with many keys including nil' do
        let(:keys)     { [0, nil, 2] }
        let(:expected) { { 'author_id' => { 'one_of' => [0, 2] } } }

        it { expect(evaluated).to be == expected }

        describe 'with allow_nil: true' do
          let(:options) { { allow_nil: true } }
          let(:expected) do
            { 'author_id' => { 'one_of' => [0, nil, 2] } }
          end

          it { expect(evaluated).to be == expected }
        end
      end

      describe 'with many non-unique keys' do
        let(:keys)     { [0, 1, 2, 1, 2] }
        let(:expected) { { 'author_id' => { 'one_of' => keys.uniq } } }

        it { expect(evaluated).to be == expected }

        describe 'with deduplicate: false' do
          let(:options) { super().merge(deduplicate: false) }
          let(:expected) do
            { 'author_id' => { 'one_of' => [0, 1, 2, 1, 2] } }
          end

          it { expect(evaluated).to be == expected }
        end
      end
    end
  end

  describe '#foreign_key_name' do
    it { expect(subject.foreign_key_name).to be nil }

    context 'when initialized with foreign_key_name: a String' do
      let(:foreign_key_name) { 'writer_id' }
      let(:constructor_options) do
        super().merge(foreign_key_name: foreign_key_name)
      end

      it { expect(subject.foreign_key_name).to be == 'writer_id' }
    end

    context 'when initialized with foreign_key_name: a String' do
      let(:foreign_key_name) { :writer_id }
      let(:constructor_options) do
        super().merge(foreign_key_name: foreign_key_name)
      end

      it { expect(subject.foreign_key_name).to be == 'writer_id' }
    end

    context 'when initialized with inverse: value' do
      let(:inverse) { described_class.new(name: 'authors') }
      let(:constructor_options) do
        super().merge(inverse: inverse)
      end

      it { expect(subject.foreign_key_name).to be == 'author_id' }

      context 'when initialized with foreign_key_name: a String' do
        let(:foreign_key_name) { 'writer_id' }
        let(:constructor_options) do
          super().merge(foreign_key_name: foreign_key_name)
        end

        it { expect(subject.foreign_key_name).to be == 'writer_id' }
      end

      context 'when initialized with foreign_key_name: a String' do
        let(:foreign_key_name) { :writer_id }
        let(:constructor_options) do
          super().merge(foreign_key_name: foreign_key_name)
        end

        it { expect(subject.foreign_key_name).to be == 'writer_id' }
      end

      context 'when initialized with inverse_name: value' do
        let(:inverse_name) { 'writers' }
        let(:constructor_options) do
          super().merge(inverse_name: inverse_name)
        end

        it { expect(subject.foreign_key_name).to be == 'author_id' }
      end

      context 'when initialized with singular_inverse_name: value' do
        let(:singular_inverse_name) { 'writer' }
        let(:constructor_options) do
          super().merge(singular_inverse_name: singular_inverse_name)
        end

        it { expect(subject.foreign_key_name).to be == 'writer_id' }
      end
    end

    context 'when initialized with inverse_name: value' do
      let(:inverse_name) { 'authors' }
      let(:constructor_options) do
        super().merge(inverse_name: inverse_name)
      end

      it { expect(subject.foreign_key_name).to be == 'author_id' }

      context 'when initialized with foreign_key_name: a String' do
        let(:foreign_key_name) { 'writer_id' }
        let(:constructor_options) do
          super().merge(foreign_key_name: foreign_key_name)
        end

        it { expect(subject.foreign_key_name).to be == 'writer_id' }
      end

      context 'when initialized with foreign_key_name: a String' do
        let(:foreign_key_name) { :writer_id }
        let(:constructor_options) do
          super().merge(foreign_key_name: foreign_key_name)
        end

        it { expect(subject.foreign_key_name).to be == 'writer_id' }
      end
    end

    context 'when initialized with singular_inverse_name: value' do
      let(:singular_inverse_name) { 'author' }
      let(:constructor_options) do
        super().merge(singular_inverse_name: singular_inverse_name)
      end

      it { expect(subject.foreign_key_name).to be == 'author_id' }

      context 'when initialized with foreign_key_name: a String' do
        let(:foreign_key_name) { 'writer_id' }
        let(:constructor_options) do
          super().merge(foreign_key_name: foreign_key_name)
        end

        it { expect(subject.foreign_key_name).to be == 'writer_id' }
      end

      context 'when initialized with foreign_key_name: a String' do
        let(:foreign_key_name) { :writer_id }
        let(:constructor_options) do
          super().merge(foreign_key_name: foreign_key_name)
        end

        it { expect(subject.foreign_key_name).to be == 'writer_id' }
      end
    end

    context 'with a copy with assigned inverse' do
      subject do
        super().tap(&:foreign_key_name).with_inverse(new_inverse)
      end

      let(:new_inverse) { described_class.new(name: 'chapters') }

      it { expect(subject.foreign_key_name).to be == 'chapter_id' }

      context 'when initialized with foreign_key_name: a String' do
        let(:foreign_key_name) { 'writer_id' }
        let(:constructor_options) do
          super().merge(foreign_key_name: foreign_key_name)
        end

        it { expect(subject.foreign_key_name).to be == 'writer_id' }
      end

      context 'when initialized with foreign_key_name: a String' do
        let(:foreign_key_name) { :writer_id }
        let(:constructor_options) do
          super().merge(foreign_key_name: foreign_key_name)
        end

        it { expect(subject.foreign_key_name).to be == 'writer_id' }
      end

      context 'when initialized with inverse: value' do
        let(:inverse) { described_class.new(name: 'authors') }
        let(:constructor_options) do
          super().merge(inverse: inverse)
        end

        it { expect(subject.foreign_key_name).to be == 'chapter_id' }
      end

      context 'when initialized with inverse_name: value' do
        let(:inverse_name) { 'authors' }
        let(:constructor_options) do
          super().merge(inverse_name: inverse_name)
        end

        it { expect(subject.foreign_key_name).to be == 'chapter_id' }
      end

      context 'when initialized with singular_inverse_name: value' do
        let(:singular_inverse_name) { 'author' }
        let(:constructor_options) do
          super().merge(singular_inverse_name: singular_inverse_name)
        end

        it { expect(subject.foreign_key_name).to be == 'author_id' }
      end
    end
  end

  describe '#inverse_key_name' do
    it { expect(subject.inverse_key_name).to be == 'id' }

    context 'when initialized with primary_key_name: a String' do
      let(:primary_key_name) { 'uuid' }
      let(:constructor_options) do
        super().merge(primary_key_name: primary_key_name)
      end

      it { expect(subject.inverse_key_name).to be == primary_key_name }
    end

    context 'when initialized with primary_key_name: a Symbol' do
      let(:primary_key_name) { :uuid }
      let(:constructor_options) do
        super().merge(primary_key_name: primary_key_name)
      end

      it 'should set the primary key name' do
        expect(subject.inverse_key_name).to be == primary_key_name.to_s
      end
    end
  end

  describe '#map_entities_to_keys' do
    let(:key)      { subject.primary_key_name }
    let(:entities) { [] }
    let(:options)  { {} }
    let(:keys)     { subject.map_entities_to_keys(*entities, **options) }

    example_class 'Spec::Entity' do |klass|
      klass.define_method(:initialize) do |**attributes|
        attributes.each do |key, value|
          instance_variable_set(:"@#{key}", value)
        end
      end

      klass.attr_reader :id
    end

    describe 'with no entities' do
      let(:entities) { [] }

      it { expect(keys).to be == [] }
    end

    describe 'with one nil entity' do
      let(:entities) { [nil] }

      it { expect(keys).to be == [] }
    end

    describe 'with one invalid entity' do
      let(:entities) { [Object.new.freeze] }
      let(:error_message) do
        "undefined method :[] or :#{key} for #{entities.first.inspect}"
      end

      it 'should raise an exception' do
        expect { association.map_entities_to_keys(*entities) }
          .to raise_error ArgumentError, error_message
      end
    end

    describe 'with one Integer' do
      let(:entities) { [0] }
      let(:error_message) do
        "undefined method :[] or :#{key} for #{entities.first.inspect}"
      end

      it 'should raise an exception' do
        expect { association.map_entities_to_keys(*entities) }
          .to raise_error ArgumentError, error_message
      end

      describe 'with strict: false' do
        it 'should raise an exception' do
          expect(
            association.map_entities_to_keys(*entities, strict: false)
          )
            .to be == entities
        end
      end

      context 'when initialized with primary_key_type: String' do
        let(:constructor_options) do
          super().merge(primary_key_type: String)
        end

        describe 'with strict: false' do
          it 'should raise an exception' do
            expect do
              association.map_entities_to_keys(*entities, strict: false)
            end
              .to raise_error ArgumentError, error_message
          end
        end
      end
    end

    describe 'with one String' do
      let(:entities) { %w[0] }
      let(:error_message) do
        "undefined method :[] or :#{key} for #{entities.first.inspect}"
      end

      it 'should raise an exception' do
        expect { association.map_entities_to_keys(*entities) }
          .to raise_error ArgumentError, error_message
      end

      describe 'with strict: false' do
        it 'should raise an exception' do
          expect do
            association.map_entities_to_keys(*entities, strict: false)
          end
            .to raise_error ArgumentError, error_message
        end
      end

      context 'when initialized with primary_key_type: String' do
        let(:constructor_options) do
          super().merge(primary_key_type: String)
        end

        describe 'with strict: false' do
          it 'should raise an exception' do
            expect(
              association.map_entities_to_keys(*entities, strict: false)
            )
              .to be == entities
          end
        end
      end
    end

    describe 'with one entity that responds to #[] and key: nil' do
      let(:entities) { [{ key => nil }] }

      it { expect(keys).to be == [] }

      describe 'with allow_nil: true' do
        let(:options) { super().merge(allow_nil: true) }

        it { expect(keys).to be == [nil] }
      end
    end

    describe 'with one entity that responds to #[] and key: value' do
      let(:entities) { [{ key => 0 }] }

      it { expect(keys).to be == [0] }
    end

    describe 'with one entity that responds to #id and key: nil' do
      let(:entities) { [Spec::Entity.new(key => nil)] }

      it { expect(keys).to be == [] }

      describe 'with allow_nil: true' do
        let(:options) { super().merge(allow_nil: true) }

        it { expect(keys).to be == [nil] }
      end
    end

    describe 'with one entity that responds to #id and key: value' do
      let(:entities) { [Spec::Entity.new(key => 0)] }

      it { expect(keys).to be == [0] }
    end

    describe 'with multiple entities' do
      let(:entities) do
        [
          Spec::Entity.new(key => 0),
          Spec::Entity.new(key => 1),
          Spec::Entity.new(key => 2)
        ]
      end

      it { expect(keys).to be == [0, 1, 2] }
    end

    describe 'with multiple entities including nil' do
      let(:entities) do
        [
          Spec::Entity.new(key => 0),
          nil,
          Spec::Entity.new(key => 1),
          nil,
          Spec::Entity.new(key => 2)
        ]
      end

      it { expect(keys).to be == [0, 1, 2] }
    end

    describe 'with multiple entities including nil ids' do
      let(:entities) do
        [
          Spec::Entity.new(key => 0),
          Spec::Entity.new(key => nil),
          Spec::Entity.new(key => 1),
          Spec::Entity.new(key => nil),
          Spec::Entity.new(key => 2)
        ]
      end

      it { expect(keys).to be == [0, 1, 2] }

      describe 'with allow_nil: true' do
        let(:options) { super().merge(allow_nil: true) }

        it { expect(keys).to be == [0, nil, 1, 2] }
      end
    end

    describe 'with multiple entities including duplicate ids' do
      let(:entities) do
        [
          Spec::Entity.new(key => 0),
          Spec::Entity.new(key => 1),
          Spec::Entity.new(key => 0),
          Spec::Entity.new(key => 1),
          Spec::Entity.new(key => 2)
        ]
      end

      it { expect(keys).to be == [0, 1, 2] }

      describe 'with deduplicate: false' do
        let(:options) { super().merge(deduplicate: false) }

        it { expect(keys).to be == [0, 1, 0, 1, 2] }
      end
    end

    describe 'with multiple Integers' do
      let(:entities) { [0, 1, 2] }
      let(:error_message) do
        "undefined method :[] or :#{key} for #{entities.first.inspect}"
      end

      it 'should raise an exception' do
        expect { association.map_entities_to_keys(*entities) }
          .to raise_error ArgumentError, error_message
      end

      describe 'with strict: false' do
        it 'should raise an exception' do
          expect(
            association.map_entities_to_keys(*entities, strict: false)
          )
            .to be == entities
        end
      end

      context 'when initialized with primary_key_type: String' do
        let(:constructor_options) do
          super().merge(primary_key_type: String)
        end

        describe 'with strict: false' do
          it 'should raise an exception' do
            expect do
              association.map_entities_to_keys(*entities, strict: false)
            end
              .to raise_error ArgumentError, error_message
          end
        end
      end
    end

    describe 'with multiple Strings' do
      let(:entities) { %w[0 1 2] }
      let(:error_message) do
        "undefined method :[] or :#{key} for #{entities.first.inspect}"
      end

      it 'should raise an exception' do
        expect { association.map_entities_to_keys(*entities) }
          .to raise_error ArgumentError, error_message
      end

      describe 'with strict: false' do
        it 'should raise an exception' do
          expect do
            association.map_entities_to_keys(*entities, strict: false)
          end
            .to raise_error ArgumentError, error_message
        end
      end

      context 'when initialized with primary_key_type: String' do
        let(:constructor_options) do
          super().merge(primary_key_type: String)
        end

        describe 'with strict: false' do
          it 'should raise an exception' do
            expect(
              association.map_entities_to_keys(*entities, strict: false)
            )
              .to be == entities
          end
        end
      end
    end
  end

  describe '#primary_key_query?' do
    it { expect(subject.primary_key_query?).to be false }
  end

  describe '#query_key_name' do
    context 'when the foreign key name is blank' do
      let(:error_message) do
        "foreign key name can't be blank"
      end

      it 'should raise an exception' do
        expect { association.query_key_name }
          .to raise_error ArgumentError, error_message
      end
    end

    context 'when initialized with foreign_key_name: a String' do
      let(:foreign_key_name) { 'writer_id' }
      let(:constructor_options) do
        super().merge(foreign_key_name: foreign_key_name)
      end

      it { expect(subject.query_key_name).to be == 'writer_id' }
    end

    context 'when initialized with foreign_key_name: a String' do
      let(:foreign_key_name) { :writer_id }
      let(:constructor_options) do
        super().merge(foreign_key_name: foreign_key_name)
      end

      it { expect(subject.query_key_name).to be == 'writer_id' }
    end

    context 'when initialized with inverse: value' do
      let(:inverse) { described_class.new(name: 'authors') }
      let(:constructor_options) do
        super().merge(inverse: inverse)
      end

      it { expect(subject.query_key_name).to be == 'author_id' }

      context 'when initialized with foreign_key_name: a String' do
        let(:foreign_key_name) { 'writer_id' }
        let(:constructor_options) do
          super().merge(foreign_key_name: foreign_key_name)
        end

        it { expect(subject.query_key_name).to be == 'writer_id' }
      end

      context 'when initialized with foreign_key_name: a String' do
        let(:foreign_key_name) { :writer_id }
        let(:constructor_options) do
          super().merge(foreign_key_name: foreign_key_name)
        end

        it { expect(subject.query_key_name).to be == 'writer_id' }
      end

      context 'when initialized with inverse_name: value' do
        let(:inverse_name) { 'writers' }
        let(:constructor_options) do
          super().merge(inverse_name: inverse_name)
        end

        it { expect(subject.query_key_name).to be == 'author_id' }
      end

      context 'when initialized with singular_inverse_name: value' do
        let(:singular_inverse_name) { 'writer' }
        let(:constructor_options) do
          super().merge(singular_inverse_name: singular_inverse_name)
        end

        it { expect(subject.query_key_name).to be == 'writer_id' }
      end
    end

    context 'when initialized with inverse_name: value' do
      let(:inverse_name) { 'authors' }
      let(:constructor_options) do
        super().merge(inverse_name: inverse_name)
      end

      it { expect(subject.query_key_name).to be == 'author_id' }

      context 'when initialized with foreign_key_name: a String' do
        let(:foreign_key_name) { 'writer_id' }
        let(:constructor_options) do
          super().merge(foreign_key_name: foreign_key_name)
        end

        it { expect(subject.query_key_name).to be == 'writer_id' }
      end

      context 'when initialized with foreign_key_name: a String' do
        let(:foreign_key_name) { :writer_id }
        let(:constructor_options) do
          super().merge(foreign_key_name: foreign_key_name)
        end

        it { expect(subject.query_key_name).to be == 'writer_id' }
      end
    end

    context 'when initialized with singular_inverse_name: value' do
      let(:singular_inverse_name) { 'author' }
      let(:constructor_options) do
        super().merge(singular_inverse_name: singular_inverse_name)
      end

      it { expect(subject.query_key_name).to be == 'author_id' }

      context 'when initialized with foreign_key_name: a String' do
        let(:foreign_key_name) { 'writer_id' }
        let(:constructor_options) do
          super().merge(foreign_key_name: foreign_key_name)
        end

        it { expect(subject.query_key_name).to be == 'writer_id' }
      end

      context 'when initialized with foreign_key_name: a String' do
        let(:foreign_key_name) { :writer_id }
        let(:constructor_options) do
          super().merge(foreign_key_name: foreign_key_name)
        end

        it { expect(subject.query_key_name).to be == 'writer_id' }
      end
    end

    context 'with a copy with assigned inverse' do
      subject do
        super().tap(&:foreign_key_name).with_inverse(new_inverse)
      end

      let(:new_inverse) { described_class.new(name: 'chapters') }

      it { expect(subject.query_key_name).to be == 'chapter_id' }

      context 'when initialized with foreign_key_name: a String' do
        let(:foreign_key_name) { 'writer_id' }
        let(:constructor_options) do
          super().merge(foreign_key_name: foreign_key_name)
        end

        it { expect(subject.query_key_name).to be == 'writer_id' }
      end

      context 'when initialized with foreign_key_name: a String' do
        let(:foreign_key_name) { :writer_id }
        let(:constructor_options) do
          super().merge(foreign_key_name: foreign_key_name)
        end

        it { expect(subject.query_key_name).to be == 'writer_id' }
      end

      context 'when initialized with inverse: value' do
        let(:inverse) { described_class.new(name: 'authors') }
        let(:constructor_options) do
          super().merge(inverse: inverse)
        end

        it { expect(subject.query_key_name).to be == 'chapter_id' }
      end

      context 'when initialized with inverse_name: value' do
        let(:inverse_name) { 'authors' }
        let(:constructor_options) do
          super().merge(inverse_name: inverse_name)
        end

        it { expect(subject.query_key_name).to be == 'chapter_id' }
      end

      context 'when initialized with singular_inverse_name: value' do
        let(:singular_inverse_name) { 'author' }
        let(:constructor_options) do
          super().merge(singular_inverse_name: singular_inverse_name)
        end

        it { expect(subject.query_key_name).to be == 'author_id' }
      end
    end
  end
end