Module: Cuprum::Rails::RSpec::Contracts::ActionContracts::ShouldValidateAttributesContract

Extended by:

RSpec::SleepingKingStudios::Contract

Defined in:

lib/cuprum/rails/rspec/contracts/action_contracts.rb

Overview

Contract asserting the action validates the created or updated entity.

Instance Method Summary

• #apply(example_group, invalid_attributes: , expected_attributes: nil, **options) { ... } ⇒ Object

  Adds the contract to the example group.

Instance Method Details

#apply(example_group, invalid_attributes: , expected_attributes: nil, **options) { ... } ⇒ Object

Adds the contract to the example group.

Parameters:

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

  The example group to which the contract is applied.

• invalid_attributes (Hash<String>) (defaults to: ) —

  A set of attributes that will fail validation.

Options Hash (**options):

• existing_entity (Object) —

  The existing entity, if any.

• expected_attributes (Hash<String>) —

  The expected attributes for the returned object. Defaults to the value of invalid_attributes.

• params (Hash<String>) —

  The parameters used to build the request. Defaults to the given attributes.

Yields:

• Additional configuration or examples.

# File 'lib/cuprum/rails/rspec/contracts/action_contracts.rb', line 654

contract do |invalid_attributes:, **options, &block|
  describe '#call' do
    include Cuprum::Rails::RSpec::ContractHelpers

    context 'when the resource params fail validation' do
      let(:request) do
        Cuprum::Rails::Request.new(params: configured_params)
      end
      let(:configured_invalid_attributes) do
        option_with_default(invalid_attributes)
      end
      let(:configured_params) do
        resource_name = configured_resource.singular_name

        option_with_default(
          options[:params],
          default: {}
        ).merge({ resource_name => configured_invalid_attributes })
      end
      let(:configured_existing_entity) do
        option_with_default(options[:existing_entity])
      end
      let(:configured_expected_attributes) do
        option_with_default(
          options[:expected_attributes],
          default: (configured_existing_entity&.attributes || {}).merge(
            configured_invalid_attributes
          )
        )
      end
      let(:configured_expected_entity) do
        if configured_existing_entity
          repository
            .find_or_create(
              qualified_name: resource.qualified_name
            )
            .assign_one
            .call(
              attributes: configured_invalid_attributes,
              entity:     configured_existing_entity.clone
            )
            .value
            .tap(&:valid?)
        else
          action
            .resource
            .entity_class
            .new(configured_expected_attributes)
            .tap(&:valid?)
        end
      end
      let(:configured_expected_value) do
        matcher =
          be_a(configured_expected_entity.class)
            .and(have_attributes(configured_expected_entity.attributes))
        option_with_default(
          options[:expected_value],
          default: {
            configured_resource.singular_name => matcher
          }
        )
      end
      let(:configured_expected_error) do
        errors =
          Cuprum::Rails::MapErrors
            .instance
            .call(native_errors: configured_expected_entity.errors)

        Cuprum::Collections::Errors::FailedValidation.new(
          entity_class: configured_resource.entity_class,
          errors:       scope_validation_errors(errors)
        )
      end

      def scope_validation_errors(errors)
        mapped_errors = Stannum::Errors.new
        resource_name = configured_resource.singular_name

        errors.each do |err|
          mapped_errors
            .dig(resource_name, *err[:path].map(&:to_s))
            .add(err[:type], message: err[:message], **err[:data])
        end

        mapped_errors
      end

      it 'should return a failing result' do
        expect(call_action)
          .to be_a_failing_result
          .with_value(deep_match(configured_expected_value))
          .and_error(configured_expected_error)
      end

      instance_exec(&block) if block
    end
  end
end