Module: Cuprum::Collections::RSpec::Contracts::Scopes::CriteriaContracts::ShouldBeACriteriaScopeContract Deprecated

Extended by:

RSpec::SleepingKingStudios::Contract

Defined in:

lib/cuprum/collections/rspec/contracts/scopes/criteria_contracts.rb

Overview

Deprecated.

0.6.0

Contract validating the behavior of a Criteria scope implementation.

Instance Method Summary

• #apply(example_group, abstract: false, constructor: true, equality: true, ignore_uninvertible: false) ⇒ Object

  Adds the contract to the example group.

Instance Method Details

#apply(example_group, abstract: false, constructor: true, equality: true, ignore_uninvertible: false) ⇒ Object

Adds the contract to the example group.

Parameters:

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

  the example group to which the contract is applied.

• abstract (Boolean) (defaults to: false) —

  if true, the scope is abstract and does not define a #call implementation. Defaults to false.

• equality (Boolean) (defaults to: true) —

  if false, skips the specs for the equality operator #==. Defaults to true.

• ignore_uninvertible (Boolean) (defaults to: false) —

  if true, skips the specs for uninvertible operators. Defaults to false.

# File 'lib/cuprum/collections/rspec/contracts/scopes/criteria_contracts.rb', line 30

contract do |
  abstract:            false,
  equality:            true,
  constructor:         true,
  ignore_uninvertible: false
|
  message =
    'Use deferred examples "should implement the CriteriaScope methods"'
  SleepingKingStudios::Tools::Toolbelt
    .instance
    .core_tools
    .deprecate(
      'ShouldBeACriteriaScopeContract',
      message:
    )

  shared_context 'when initialized with inverted: true' do
    let(:constructor_options) { super().merge(inverted: true) }
  end

  shared_context 'with criteria' do
    let(:criteria) do
      operators = Cuprum::Collections::Queries::Operators

      [
        ['title',  operators::EQUAL, 'Gideon the Ninth'],
        ['author', operators::EQUAL, 'Tamsyn Muir']
      ]
    end
  end

  let(:criteria) { [] }

  describe '.new' do
    next unless constructor

    it 'should define the constructor' do
      expect(described_class)
        .to be_constructible
        .with(0).arguments
        .and_keywords(:criteria, :inverted)
        .and_any_keywords
    end
  end

  describe '.build' do
    let(:value) { { 'title' => 'The Word for World is Forest' } }

    def parse_criteria(*args, &block)
      return described_class.build(&block).criteria if args.empty?

      described_class.build(args.first, &block).criteria
    end

    it 'should define class method' do
      expect(described_class)
        .to respond_to(:build)
        .with(0..1).arguments
        .and_a_block
    end

    it { expect(described_class.build(value)).to be_a described_class }

    include_contract 'should parse criteria'
  end

  describe '.parse' do
    def parse_criteria(*args, &block)
      return described_class.parse(&block) if args.empty?

      described_class.parse(args.first, &block)
    end

    it 'should define class method' do
      expect(described_class)
        .to respond_to(:parse)
        .with(0..1).arguments
        .and_a_block
    end

    include_contract 'should parse criteria'
  end

  include_contract 'should be a scope', invertible: true

  include_contract 'should compose scopes for criteria'

  describe '#==' do
    next unless equality

    describe 'with a scope with the same class' do
      let(:other_criteria) { [] }
      let(:other_inverted) { false }
      let(:other) do
        described_class.new(
          criteria: other_criteria,
          inverted: other_inverted
        )
      end

      describe 'with empty criteria' do
        let(:other_criteria) { [] }

        it { expect(subject == other).to be true }

        describe 'with inverted: true' do
          let(:other_inverted) { true }

          it { expect(subject == other).to be false }
        end
      end

      describe 'with non-matching criteria' do
        let(:other_criteria) do
          operators = Cuprum::Collections::Queries::Operators

          [
            [
              'ok',
              operators::EQUAL,
              true
            ]
          ]
        end

        it { expect(subject == other).to be false }

        describe 'with inverted: true' do
          let(:other_inverted) { true }

          it { expect(subject == other).to be false }
        end
      end

      wrap_context 'with criteria' do
        describe 'with empty criteria' do
          let(:other_criteria) { [] }

          it { expect(subject == other).to be false }

          describe 'with inverted: true' do
            let(:other_inverted) { true }

            it { expect(subject == other).to be false }
          end
        end

        describe 'with non-matching criteria' do
          let(:other_criteria) do
            operators = Cuprum::Collections::Queries::Operators

            [
              [
                'ok',
                operators::EQUAL,
                true
              ]
            ]
          end

          it { expect(subject == other).to be false }

          describe 'with inverted: true' do
            let(:other_inverted) { true }

            it { expect(subject == other).to be false }
          end
        end

        describe 'with matching criteria' do
          let(:other_criteria) { subject.criteria }

          it { expect(subject == other).to be true }

          describe 'with inverted: true' do
            let(:other_inverted) { true }

            it { expect(subject == other).to be false }
          end
        end
      end

      wrap_context 'when initialized with inverted: true' do
        describe 'with empty criteria' do
          let(:other_criteria) { [] }

          it { expect(subject == other).to be false }

          describe 'with inverted: true' do
            let(:other_inverted) { true }

            it { expect(subject == other).to be true }
          end
        end

        describe 'with non-matching criteria' do
          let(:other_criteria) do
            operators = Cuprum::Collections::Queries::Operators

            [
              [
                'ok',
                operators::EQUAL,
                true
              ]
            ]
          end

          it { expect(subject == other).to be false }

          describe 'with inverted: true' do
            let(:other_inverted) { true }

            it { expect(subject == other).to be false }
          end
        end

        wrap_context 'with criteria' do
          describe 'with empty criteria' do
            let(:other_criteria) { [] }

            it { expect(subject == other).to be false }

            describe 'with inverted: true' do
              let(:other_inverted) { true }

              it { expect(subject == other).to be false }
            end
          end

          describe 'with non-matching criteria' do
            let(:other_criteria) do
              operators = Cuprum::Collections::Queries::Operators

              [
                [
                  'ok',
                  operators::EQUAL,
                  true
                ]
              ]
            end

            it { expect(subject == other).to be false }

            describe 'with inverted: true' do
              let(:other_inverted) { true }

              it { expect(subject == other).to be false }
            end
          end

          describe 'with matching criteria' do
            let(:other_criteria) { subject.criteria }

            it { expect(subject == other).to be false }

            describe 'with inverted: true' do
              let(:other_inverted) { true }

              it { expect(subject == other).to be true }
            end
          end
        end
      end
    end

    describe 'with a scope with the same type' do
      let(:other_criteria) { [] }
      let(:other_inverted) { false }
      let(:other) do
        described_class.new(
          criteria: other_criteria,
          inverted: other_inverted
        )
      end

      example_class 'Spec::CustomScope',
        Cuprum::Collections::Scopes::Base \
      do |klass|
        klass.include Cuprum::Collections::Scopes::Criteria
      end

      describe 'with empty criteria' do
        let(:other_criteria) { [] }

        it { expect(subject == other).to be true }

        describe 'with inverted: true' do
          let(:other_inverted) { true }

          it { expect(subject == other).to be false }
        end
      end

      describe 'with non-matching criteria' do
        let(:other_criteria) do
          operators = Cuprum::Collections::Queries::Operators

          [
            [
              'ok',
              operators::EQUAL,
              true
            ]
          ]
        end

        it { expect(subject == other).to be false }

        describe 'with inverted: true' do
          let(:other_inverted) { true }

          it { expect(subject == other).to be false }
        end
      end

      wrap_context 'with criteria' do
        describe 'with empty criteria' do
          let(:other_criteria) { [] }

          it { expect(subject == other).to be false }

          describe 'with inverted: true' do
            let(:other_inverted) { true }

            it { expect(subject == other).to be false }
          end
        end

        describe 'with non-matching criteria' do
          let(:other_criteria) do
            operators = Cuprum::Collections::Queries::Operators

            [
              [
                'ok',
                operators::EQUAL,
                true
              ]
            ]
          end

          it { expect(subject == other).to be false }

          describe 'with inverted: true' do
            let(:other_inverted) { true }

            it { expect(subject == other).to be false }
          end
        end

        describe 'with matching criteria' do
          let(:other_criteria) { subject.criteria }

          it { expect(subject == other).to be true }

          describe 'with inverted: true' do
            let(:other_inverted) { true }

            it { expect(subject == other).to be false }
          end
        end
      end

      wrap_context 'when initialized with inverted: true' do
        describe 'with empty criteria' do
          let(:other_criteria) { [] }

          it { expect(subject == other).to be false }

          describe 'with inverted: true' do
            let(:other_inverted) { true }

            it { expect(subject == other).to be true }
          end
        end

        describe 'with non-matching criteria' do
          let(:other_criteria) do
            operators = Cuprum::Collections::Queries::Operators

            [
              [
                'ok',
                operators::EQUAL,
                true
              ]
            ]
          end

          it { expect(subject == other).to be false }

          describe 'with inverted: true' do
            let(:other_inverted) { true }

            it { expect(subject == other).to be false }
          end
        end

        wrap_context 'with criteria' do
          describe 'with empty criteria' do
            let(:other_criteria) { [] }

            it { expect(subject == other).to be false }

            describe 'with inverted: true' do
              let(:other_inverted) { true }

              it { expect(subject == other).to be false }
            end
          end

          describe 'with non-matching criteria' do
            let(:other_criteria) do
              operators = Cuprum::Collections::Queries::Operators

              [
                [
                  'ok',
                  operators::EQUAL,
                  true
                ]
              ]
            end

            it { expect(subject == other).to be false }

            describe 'with inverted: true' do
              let(:other_inverted) { true }

              it { expect(subject == other).to be false }
            end
          end

          describe 'with matching criteria' do
            let(:other_criteria) { subject.criteria }

            it { expect(subject == other).to be false }

            describe 'with inverted: true' do
              let(:other_inverted) { true }

              it { expect(subject == other).to be true }
            end
          end
        end
      end
    end
  end

  describe '#as_json' do
    let(:expected) do
      {
        'criteria' => subject.criteria,
        'inverted' => subject.inverted?,
        'type'     => subject.type
      }
    end

    it { expect(subject.as_json).to be == expected }

    wrap_context 'when initialized with inverted: true' do
      it { expect(subject.as_json).to be == expected }
    end

    wrap_context 'with criteria' do
      it { expect(subject.as_json).to be == expected }

      wrap_context 'when initialized with inverted: true' do
        it { expect(subject.as_json).to be == expected }
      end
    end
  end

  describe '#call' do
    next if abstract

    it { expect(subject).to respond_to(:call) }

    include_contract 'should filter data by criteria'

    context 'when the scope is inverted' do
      subject { super().invert }

      let(:matching_data) { data - filtered_data }

      include_contract 'should filter data by criteria',
        ignore_invalid: true,
        inverted:       true
    end
  end

  describe '#criteria' do
    include_examples 'should define reader', :criteria, -> { criteria }

    wrap_context 'with criteria' do
      it { expect(subject.criteria).to be == criteria }
    end
  end

  describe '#empty?' do
    include_examples 'should define predicate', :empty?, true

    wrap_context 'with criteria' do
      it { expect(subject.empty?).to be false }
    end
  end

  describe '#invert' do
    shared_examples 'should invert the criteria' do
      it { expect(copy.criteria).to be == [] }

      context 'when the scope has an equality criterion' do
        let(:criteria) do
          described_class.parse({
            'title' => 'The Word for World is Forest'
          })
        end
        let(:expected) do
          operators = Cuprum::Collections::Queries::Operators

          [
            [
              'title',
              operators::NOT_EQUAL,
              'The Word for World is Forest'
            ]
          ]
        end

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

      context 'when the scope has a greater than criterion' do
        let(:criteria) do
          described_class.parse do |scope|
            { 'published_at' => scope.greater_than('1972-03-13') }
          end
        end
        let(:expected) do
          operators = Cuprum::Collections::Queries::Operators

          [
            [
              'published_at',
              operators::LESS_THAN_OR_EQUAL_TO,
              '1972-03-13'
            ]
          ]
        end

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

      context 'when the scope has a greater than or equal to criterion' do
        let(:criteria) do
          described_class.parse do |scope|
            {
              'published_at' => scope.greater_than_or_equal_to(
                '1972-03-13'
              )
            }
          end
        end
        let(:expected) do
          operators = Cuprum::Collections::Queries::Operators

          [
            [
              'published_at',
              operators::LESS_THAN,
              '1972-03-13'
            ]
          ]
        end

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

      context 'when the scope has a less than criterion' do
        let(:criteria) do
          described_class.parse do |scope|
            { 'published_at' => scope.less_than('1972-03-13') }
          end
        end
        let(:expected) do
          operators = Cuprum::Collections::Queries::Operators

          [
            [
              'published_at',
              operators::GREATER_THAN_OR_EQUAL_TO,
              '1972-03-13'
            ]
          ]
        end

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

      context 'when the scope has a less than or equal to criterion' do
        let(:criteria) do
          described_class.parse do |scope|
            {
              'published_at' => scope.less_than_or_equal_to(
                '1972-03-13'
              )
            }
          end
        end
        let(:expected) do
          operators = Cuprum::Collections::Queries::Operators

          [
            [
              'published_at',
              operators::GREATER_THAN,
              '1972-03-13'
            ]
          ]
        end

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

      context 'when the scope has a not equal criterion' do
        let(:criteria) do
          described_class.parse do |scope|
            { 'author' => scope.not_equal('J.R.R. Tolkien') }
          end
        end
        let(:expected) do
          operators = Cuprum::Collections::Queries::Operators

          [
            [
              'author',
              operators::EQUAL,
              'J.R.R. Tolkien'
            ]
          ]
        end

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

      context 'when the scope has a not one of criterion' do
        let(:criteria) do
          described_class.parse do |scope|
            titles = ['The Fellowship Of The Ring', 'The Two Towers']

            { 'title' => scope.not_one_of(titles) }
          end
        end
        let(:expected) do
          operators = Cuprum::Collections::Queries::Operators

          [
            [
              'title',
              operators::ONE_OF,
              ['The Fellowship Of The Ring', 'The Two Towers']
            ]
          ]
        end

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

      context 'when the scope has a one of criterion' do
        let(:criteria) do
          described_class.parse do |scope|
            titles = ['The Fellowship Of The Ring', 'The Two Towers']

            { 'title' => scope.one_of(titles) }
          end
        end
        let(:expected) do
          operators = Cuprum::Collections::Queries::Operators

          [
            [
              'title',
              operators::NOT_ONE_OF,
              ['The Fellowship Of The Ring', 'The Two Towers']
            ]
          ]
        end

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

      context 'when the scope has multiple criteria' do
        let(:criteria) do
          described_class.parse do |scope|
            titles = ['The Fellowship Of The Ring', 'The Two Towers']

            {
              'author' => 'J.R.R. Tolkien',
              'title'  => scope.not_one_of(titles)
            }
          end
        end
        let(:expected) do
          operators = Cuprum::Collections::Queries::Operators

          [
            [
              'author',
              operators::NOT_EQUAL,
              'J.R.R. Tolkien'
            ],
            [
              'title',
              operators::ONE_OF,
              ['The Fellowship Of The Ring', 'The Two Towers']
            ]
          ]
        end

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

      context 'when initialized with uninvertible criteria' do
        next if ignore_uninvertible

        let(:criteria) do
          [
            [
              'title',
              'random',
              nil
            ]
          ]
        end
        let(:error_class) do
          Cuprum::Collections::Queries::UninvertibleOperatorException
        end
        let(:error_message) { 'uninvertible operator "random"' }

        it 'should raise an exception' do
          expect { subject.invert }
            .to raise_error error_class, error_message
        end
      end
    end

    let(:copy) { subject.invert }

    it { expect(copy).to be_a described_class }

    it { expect(copy.inverted?).to be true }

    include_examples 'should invert the criteria'

    wrap_context 'when initialized with inverted: true' do
      it { expect(copy).to be_a described_class }

      it { expect(copy.inverted?).to be false }

      include_examples 'should invert the criteria'
    end
  end

  describe '#inverted?' do
    include_examples 'should define predicate', :inverted?, false

    wrap_context 'when initialized with inverted: true' do
      it { expect(subject.inverted?).to be true }
    end
  end

  describe '#type' do
    include_examples 'should define reader', :type, :criteria
  end

  describe '#with_criteria' do
    let(:new_criteria) { ['author', 'eq', 'Ursula K. LeGuin'] }

    it { expect(subject).to respond_to(:with_criteria).with(1).argument }

    it 'should return a scope' do
      expect(subject.with_criteria(new_criteria)).to be_a described_class
    end

    it "should not change the original scope's criteria" do
      expect { subject.with_criteria(new_criteria) }
        .not_to change(subject, :criteria)
    end

    it "should set the copied scope's criteria" do
      expect(subject.with_criteria(new_criteria).criteria)
        .to be == new_criteria
    end

    it 'should return an uninverted scope' do
      expect(subject.with_criteria(new_criteria).inverted?).to be false
    end

    wrap_context 'with criteria' do
      it "should not change the original scope's criteria" do
        expect { subject.with_criteria(new_criteria) }
          .not_to change(subject, :criteria)
      end

      it "should set the copied scope's criteria" do
        expect(subject.with_criteria(new_criteria).criteria)
          .to be == new_criteria
      end
    end

    wrap_context 'when initialized with inverted: true' do
      it 'should return an inverted scope' do
        expect(subject.with_criteria(new_criteria).inverted?).to be true
      end
    end
  end
end