feature: have_attribute value matcher as second argument

[Justin-Maxwell]

Hi.

I've started extending have_attribute to accept an optional RSpec matcher as a second argument, so that flattening logic and such like can be tested. This is my first attempt at forking and extending a gem, so I'm feeling my way through the process somewhat clumsily.

So any tips or advice greatly appreciated - it'll be slow going, so a while before any pull request I expect.

This seems to be basically working though - posting the below incase I'm going about this in drastically the wrong way...

    describe "attributes" do
      let(:author) { Author.new(name: "name") }
      subject(:resource) { AuthorResource.new(author, {}) }
      context 'original without testing attribute value' do
        it { is_expected.to have_attribute(:name) }
        it { is_expected.to_not have_attribute(:created_at) }
      end
      context 'with attribute value tested' do
        it { is_expected.to have_attribute( :name, eq('name')) }
        it { is_expected.to_not have_attribute( :name, eq('fred')) }
        it { is_expected.to have_attribute( :name, start_with('na')) }
        it { is_expected.to_not have_attribute( :name, start_with('fr')) }
        it { is_expected.to have_attribute( :name, match(/a/))  }
        it { is_expected.to_not have_attribute( :name, match(/b/))  }
        it { is_expected.to have_attribute( :name, 'name')  }
        it { is_expected.to_not have_attribute( :name, 'fred')  }
      end

      def have_attribute(name, matcher=nil)
        HaveAttribute.new(name, matcher)
      end

class HaveAttribute      
     attr_accessor :name, :resource, :matcher

        def initialize(name, matcher)
          self.name = name
          self.matcher = matcher
          self.matcher = RSpec::Matchers::BuiltIn::Eq.new(matcher) if matcher && ! defined?(matcher.matches?)
        end
...
          return false unless attributes.has_key?(expected_key)
          @attribute_found= true
          return matcher.nil? || matcher === attributes[expected_key]
        end

        def failure_message
          resource_name = resource.class.name.demodulize
          if @attribute_found
            msg= %Q(#{matcher&.failure_message} for #{resource_name} attribute #{name})
          else
            msg= %Q(expected #{resource_name} to have attribute #{name})
          end
          msg
        end

[ramontayag]

@Justin-Maxwell this is interesting - I have not seen RSpec used this way so I wouldn't be able to tell you if you're doing it correctly or not.

[Justin-Maxwell]

It's going to be a while till I get back to this. I want to change it to
it { is_expected.to have_attribute( name: 'name') } to be more consistent with other matchers, and also develop a matcher to check for the presence/absence of a related resource. This has allowed us to beef up our resource specs and simplify our request specs in a way that feels 'right'.

[ramontayag]

If the first argument is always the name, is it unclear to you if there is no key name?

[Justin-Maxwell]

Sorry, bad example - in this case the attributes name was 'name'.
it { is_expected.to have_attribute( author: 'fred') }

[ramontayag]

Hmm... it seems like we shouldn't be putting exact tests in the external facing part of the matchers, but rather keeping them in the matchers (in the gem) itself so that users don't have to worry about setting it to one thing or another.

[BatuhanW]

Unless I'm missing something, I think it's unnecessary to test values on resource specs. If you need to test that values proper or not, you should test these on unit tests for the model. On resource specs, it's adequate to test that you set up attributes, relationships, sorts, filters correctly and not missing something. @Justin-Maxwell