smart_rspec 0.1.3 → 0.2.0

data/spec/smart_rspec/matchers_spec.rb

@@ -1,173 +1,234 @@
 require 'spec_helper'
 
-describe 'SmartRspec Matchers' do
-  describe '#be_ascending' do
-    context 'when valid' do
-      it { expect([1, 2, 3, 4]).to be_ascending }
-    end
+describe SmartRspec::Matchers do
+  describe BeMatchers do
+    describe '#be_ascending' do
+      context 'positive assertion' do
+        it { expect([1, 2, 3, 4]).to be_ascending }
+      end
 
-    context 'when invalid' do
-      it { expect([1, 4, 2, 3]).not_to be_ascending }
+      context 'negative assertion' do
+        it { expect([1, 4, 2, 3]).not_to be_ascending }
+      end
     end
-  end
 
-  describe '#be_boolean' do
-    context 'when valid' do
-      it { expect(true).to be_boolean }
-      it { expect(false).to be_boolean }
-    end
+    describe '#be_boolean' do
+      context 'positive assertion' do
+        it { expect(true).to be_boolean }
+        it { expect(false).to be_boolean }
+      end
 
-    context 'when invalid' do
-      it { expect('true').not_to be_boolean }
-      it { expect(1).not_to be_boolean }
-      it { expect(%w(foo bar)).not_to be_boolean }
+      context 'negative assertion' do
+        it { expect('true').not_to be_boolean }
+        it { expect(1).not_to be_boolean }
+        it { expect(%w(foo bar)).not_to be_boolean }
+      end
     end
-  end
 
-  describe '#be_descending' do
-    context 'when valid' do
-      it { expect([4, 3, 2, 1]).to be_descending }
-    end
+    describe '#be_descending' do
+      context 'positive assertion' do
+        it { expect([4, 3, 2, 1]).to be_descending }
+      end
 
-    context 'when invalid' do
-      it { expect([1, 2, 3, 4]).not_to be_descending }
+      context 'negative assertion' do
+        it { expect([1, 2, 3, 4]).not_to be_descending }
+      end
     end
-  end
 
-  describe '#be_email' do
-    context 'when valid' do
-      it { expect(Faker::Internet.email).to be_email }
-      it { expect('tiagopog@gmail.com').to be_email }
-      it { expect('foo@bar.com.br').to be_email }
-    end
+    describe '#be_email' do
+      context 'positive assertion' do
+        it { expect(Faker::Internet.email).to be_email }
+        it { expect('tiagopog@gmail.com').to be_email }
+        it { expect('foo@bar.com.br').to be_email }
+      end
 
-    context 'when invalid' do
-      it { expect('foo@bar').not_to be_email }
-      it { expect('foo@').not_to be_email }
-      it { expect('@bar').not_to be_email }
-      it { expect('@bar.com').not_to be_email }
-      it { expect('foo bar@bar.com').not_to be_email }
+      context 'negative assertion' do
+        it { expect('foo@bar').not_to be_email }
+        it { expect('foo@').not_to be_email }
+        it { expect('@bar').not_to be_email }
+        it { expect('@bar.com').not_to be_email }
+        it { expect('foo bar@bar.com').not_to be_email }
+      end
     end
-  end
 
-  describe '#be_url' do
-    context 'when valid' do
-      it { expect(Faker::Internet.url).to be_url }
-      it { expect('http://adtangerine.com').to be_url }
-      it { expect('http://www.facebook.com').to be_url }
-      it { expect('www.twitflink.com').to be_url }
-      it { expect('google.com.br').to be_url }
-    end
+    describe '#be_url' do
+      context 'positive assertion' do
+        it { expect(Faker::Internet.url).to be_url }
+        it { expect('http://adtangerine.com').to be_url }
+        it { expect('http://www.facebook.com').to be_url }
+        it { expect('www.twitflink.com').to be_url }
+        it { expect('google.com.br').to be_url }
+      end
 
-    context 'when invalid' do
-      it { expect('foobar.bar').not_to be_url }
-      it { expect('foobar').not_to be_url }
-      it { expect('foo bar.com.br').not_to be_url }
+      context 'negative assertion' do
+        it { expect('foobar.bar').not_to be_url }
+        it { expect('foobar').not_to be_url }
+        it { expect('foo bar.com.br').not_to be_url }
+      end
     end
-  end
 
-  describe '#be_image_url' do
-    context 'when valid' do
-      it { expect(Faker::Company.logo).to be_image_url }
-      it { expect('http://foobar.com/foo.jpg').to be_image_url }
-      it { expect('http://foobar.com/foo.jpg').to be_image_url(:jpg) }
-      it { expect('http://foobar.com/foo.gif').to be_image_url(:gif) }
-      it { expect('http://foobar.com/foo.png').to be_image_url(:png) }
-      it { expect('http://foobar.com/foo.png').to be_image_url([:jpg, :png]) }
-      it { expect('http://foobar.com/foo/bar?image=foo.jpg').to be_image_url }
-    end
+    describe '#be_image_url' do
+      context 'positive assertion' do
+        it { expect(Faker::Company.logo).to be_image_url }
+        it { expect('http://foobar.com/foo.jpg').to be_image_url }
+        it { expect('http://foobar.com/foo.jpg').to be_image_url(:jpg) }
+        it { expect('http://foobar.com/foo.gif').to be_image_url(:gif) }
+        it { expect('http://foobar.com/foo.png').to be_image_url(:png) }
+        it { expect('http://foobar.com/foo.png').to be_image_url([:jpg, :png]) }
+        it { expect('http://foobar.com/foo/bar?image=foo.jpg').to be_image_url }
+      end
 
-    context 'when invalid' do
-      it { expect('http://foobar.com').not_to be_image_url }
-      it { expect('http://foobar.com/foo.jpg').not_to be_image_url(:gif) }
-      it { expect('http://foobar.com/foo.gif').not_to be_image_url(:png) }
-      it { expect('http://foobar.com/foo.png').not_to be_image_url(:jpg) }
-      it { expect('http://foobar.com/foo.gif').not_to be_image_url([:jpg, :png]) }
+      context 'negative assertion' do
+        it { expect('http://foobar.com').not_to be_image_url }
+        it { expect('http://foobar.com/foo.jpg').not_to be_image_url(:gif) }
+        it { expect('http://foobar.com/foo.gif').not_to be_image_url(:png) }
+        it { expect('http://foobar.com/foo.png').not_to be_image_url(:jpg) }
+        it { expect('http://foobar.com/foo.gif').not_to be_image_url([:jpg, :png]) }
+      end
     end
-  end
 
-  describe '#have' do
-    context 'when valid' do
-      it { expect([1]).to have(1).item }
-      it { expect(%w(foo bar)).to have(2).items }
-    end
+    describe '#be_a_list_of' do
+      context 'positive assertion' do
+        subject { Array.new(3, User.new) }
+        it { is_expected.to be_a_list_of(User) }
+      end
 
-    context 'when invalid' do
-      it { expect([1]).not_to have(2).items }
-      it { expect(%w(foo bar)).not_to have(1).item }
+      context 'negative assertion' do
+        subject { Array.new(3, User.new) << nil }
+        it { is_expected.to_not be_a_list_of(User) }
+      end
     end
   end
 
-  describe '#have_at_least' do
-    context 'when valid' do
-      it { expect(%w(foo bar foobar)).to have_at_least(3).items }
-    end
-  end
+  describe JsonApiMatchers do
+    subject(:response) { Fixtures::Response.new }
+
+    describe '#have_primary_data' do
+      context 'positive assertion' do
+        it do
+          expect(response).to have_primary_data('users')
+        end
+      end
 
-  describe '#have_at_most' do
-    context 'when valid' do
-      it { expect(%w(foo bar foobar)).to have_at_most(3).items }
+      context 'negative assertion' do
+        it do
+          expect(response).not_to have_primary_data('foobar')
+        end
+      end
     end
-  end
 
-  describe '#have_error_on' do
-    subject { User.new(email: nil, name: Faker::Name.name) }
+    describe '#have_data_attributes' do
+      let(:fields) { %w(first_name last_name full_name birthday) }
+
+      context 'positive assertion' do
+        it do
+          expect(response).to have_data_attributes(fields)
+        end
+      end
 
-    context 'when valid' do
-      it do
-        subject.valid?
-        is_expected.to have_error_on(:email)
+      context 'negative assertion' do
+        it do
+          expect(response).not_to have_data_attributes(fields + %w(foobar))
+        end
       end
     end
 
-    context 'when invalid' do
-      it do
-        subject.valid?
-        is_expected.not_to have_error_on(:name)
+    describe '#have_relationships' do
+      let(:relationships) { %w(posts) }
+
+      context 'positive assertion' do
+        it do
+          expect(response).to have_relationships(relationships)
+        end
+      end
+
+      context 'negative assertion' do
+        it do
+          expect(response).not_to have_relationships(relationships + %w(foobar))
+        end
       end
     end
-  end
 
-  describe '#include_items' do
-    context 'when valid' do
-      it { expect(%w(foo bar foobar)).to include_items(%w(foo bar foobar)) }
-      it { expect(%w(lorem ipsum)).to include_items('lorem', 'ipsum') }
-      it { expect([1, 'foo', ['bar']]).to include_items([1, 'foo', ['bar']]) }
+    describe '#have_included_relationships' do
+      let(:relationships) { %w(posts) }
+
+      context 'positive assertion' do
+        it do
+          expect(response).to have_included_relationships
+        end
+      end
     end
 
-    context 'when invalid' do
-      it { expect(%w(foo bar foobar)).not_to include_items(%w(lorem)) }
+    describe '#have_meta_record_count' do
+      context 'positive assertion' do
+        it do
+          expect(response).to have_meta_record_count(2)
+        end
+      end
+
+      context 'negative assertion' do
+        it do
+          expect(response).not_to have_meta_record_count(3)
+        end
+      end
     end
   end
 
-  describe '#be_a_list_of' do
-    context 'when valid' do
-      subject { Array.new(3, User.new) }
-      it { is_expected.to be_a_list_of(User) }
+  describe OtherMatchers do
+    describe '#have_error_on' do
+      subject { User.new(email: nil, name: Faker::Name.name) }
+
+      context 'positive assertion' do
+        it do
+          subject.valid?
+          is_expected.to have_error_on(:email)
+        end
+      end
+
+      context 'negative assertion' do
+        it do
+          subject.valid?
+          is_expected.not_to have_error_on(:name)
+        end
+      end
     end
 
-    context 'when invalid' do
-      subject { Array.new(3, User.new) << nil }
-      it { is_expected.to_not be_a_list_of(User) }
+    describe '#include_items' do
+      context 'positive assertion' do
+        it { expect(%w(foo bar foobar)).to include_items(%w(foo bar foobar)) }
+        it { expect(%w(lorem ipsum)).to include_items('lorem', 'ipsum') }
+        it { expect([1, 'foo', ['bar']]).to include_items([1, 'foo', ['bar']]) }
+      end
+
+      context 'negative assertion' do
+        it { expect(%w(foo bar foobar)).not_to include_items(%w(lorem)) }
+      end
     end
   end
 
-  describe '#be_a_bad_request' do
-    let(:response) { double('http response') }
+  describe ::RSpec::CollectionMatchers do
+    describe '#have' do
+      context 'positive assertion' do
+        it { expect([1]).to have(1).item }
+        it { expect(%w(foo bar)).to have(2).items }
+      end
 
-    context 'ok' do
-      before { allow(response).to receive(:code).and_return(200) }
-      it { expect(response).to_not be_a_bad_request }
+      context 'negative assertion' do
+        it { expect([1]).not_to have(2).items }
+        it { expect(%w(foo bar)).not_to have(1).item }
+      end
     end
 
-    context 'not found' do
-      before { allow(response).to receive(:code).and_return(404) }
-      it { expect(response).to be_a_bad_request }
+    describe '#have_at_least' do
+      context 'positive assertion' do
+        it { expect(%w(foo bar foobar)).to have_at_least(3).items }
+      end
     end
 
-    context 'unauthorized' do
-      before { allow(response).to receive(:code).and_return(401) }
-      it { expect(response).to be_a_bad_request }
+    describe '#have_at_most' do
+      context 'positive assertion' do
+        it { expect(%w(foo bar foobar)).to have_at_most(3).items }
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -2,7 +2,7 @@ require 'bundler/setup'
 require 'rubygems'
 require 'smart_rspec'
 require 'faker'
-require 'factories/user'
-
-include Factories
+require 'fixtures/user'
+require 'fixtures/response'
 
+include Fixtures

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smart_rspec
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Tiago Guedes
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-06-13 00:00:00.000000000 Z
+date: 2021-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: rspec-collection_matchers
   requirement: !ruby/object:Gem::Requirement
@@ -50,56 +50,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: faker
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.5'
 description: Collection of useful macros and matchers for RSpec tests of models/controllers
   in Rails-based apps.
 email:
@@ -119,13 +119,17 @@ files:
 - lib/smart_rspec/macros.rb
 - lib/smart_rspec/matchers.rb
 - lib/smart_rspec/matchers/be_matchers.rb
+- lib/smart_rspec/matchers/json_api_matchers.rb
 - lib/smart_rspec/matchers/other_matchers.rb
-- lib/smart_rspec/support/assertions.rb
-- lib/smart_rspec/support/expectations.rb
+- lib/smart_rspec/support/controller/response.rb
+- lib/smart_rspec/support/model/assertions.rb
+- lib/smart_rspec/support/model/expectations.rb
 - lib/smart_rspec/support/regexes.rb
 - lib/smart_rspec/version.rb
 - smart_rspec.gemspec
-- spec/factories/user.rb
+- spec/fixtures/response.rb
+- spec/fixtures/user.rb
+- spec/fixtures/users.json
 - spec/smart_rspec/macros_spec.rb
 - spec/smart_rspec/matchers_spec.rb
 - spec/spec_helper.rb
@@ -133,7 +137,7 @@ homepage: https://github.com/tiagopog/smart_rspec
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -148,13 +152,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.6
-signing_key: 
+rubyforge_project:
+rubygems_version: 2.7.7
+signing_key:
 specification_version: 4
 summary: Macros and matchers to make your RSpec tests even more amazing.
 test_files:
-- spec/factories/user.rb
+- spec/fixtures/response.rb
+- spec/fixtures/user.rb
+- spec/fixtures/users.json
 - spec/smart_rspec/macros_spec.rb
 - spec/smart_rspec/matchers_spec.rb
 - spec/spec_helper.rb

data/lib/smart_rspec/support/assertions.rb

@@ -1,119 +0,0 @@
-module SmartRspec
-  module Support
-    module Assertions
-      private_class_method
-
-      def validates_email_of(attr, validation)
-        it 'has an invalid format' do
-          %w(foobar foobar@ @foobar foo@bar).each do |e|
-            validation_expectation(attr, e)
-          end
-        end
-      end
-
-      def validates_exclusion_of(attr, validation)
-        it 'has a reserved value' do
-          validation_expectation(attr, validation[:in].sample)
-        end
-      end
-
-      def validates_format_of(attr, validation)
-        it 'does not match the required format' do
-          mock, with =
-            validation.values_at(:mock).first,
-            validation.values_at(:with).first
-
-          if mock && with && with !~ mock
-            validation_expectation(attr, mock)
-          else
-            raise ArgumentError, ':with and :mock are required when using the :format validation'
-          end
-        end
-      end
-
-      def validates_inclusion_of(attr, validation)
-        it 'is out of the scope of possible values' do
-          begin
-            value = SecureRandom.hex
-          end while validation[:in].include?(value)
-          validation_expectation(attr, value)
-        end
-      end
-
-      def validates_length_of(attr, validation)
-        validation.each do |key, value|
-          next unless [:in, :is, :maximum, :minimum, :within].include?(key)
-          txt, n = build_length_validation(key, value)
-          it txt do
-            validation_expectation(attr, 'x' * n)
-          end
-        end
-      end
-
-      def validates_presence_of(attr, validation)
-        it 'is blank' do
-          validation_expectation(attr, nil)
-        end
-      end
-
-      def validates_uniqueness_of(attr, validation)
-        scoped = scoped_validation?(validation)
-        it "is already in use#{" (scope: #{validation[:scope]})" if scoped}" do
-          mock =
-            if scoped
-              copy = subject.send(validation[:scope])
-              validation[:mock].send("#{validation[:scope]}=", copy)
-              validation[:mock]
-            else
-              subject.dup
-            end
-          subject.save unless subject.persisted?
-          validation_expectation(attr, subject.send(attr), mock)
-        end
-      end
-
-      def assert_has_attributes(attrs, options)
-        type_str = build_type_str(options)
-
-        attrs.each do |attr|
-          it %Q(has an attribute named "#{attr}"#{type_str}) do
-            expect(subject).to respond_to(attr)
-            has_attributes_expectation(attr, options)
-          end
-        end
-      end
-
-      def assert_association(type, associations)
-        associations.each do |model|
-          it "#{type.to_s.gsub('_', ' ')} #{model}" do
-            expect(subject).to respond_to(model)
-            association_expectation(type, model)
-          end
-        end
-      end
-
-      def build_length_validation(key, value)
-        case key
-        when :in, :within then ['is out of the length range', value.max + 1]
-        when :is, :minimum then ["is #{key == :is ? 'invalid' : 'too short'}", value - 1]
-        when :maximum then ['is too long', value + 1]
-        end
-      end
-
-      def build_type_str(options)
-        if !options.nil? && options[:type]
-          " (%s%s%s)" % [
-            ('Enumerated ' if options[:enum]),
-            options[:type],
-            (", default: #{options[:default]}" if options[:default])
-          ]
-        end
-      end
-
-      def scoped_validation?(validation)
-        validation.is_a?(Hash) && ([:scope, :mock] - validation.keys).empty?
-      end
-    end
-  end
-end
-

data/lib/smart_rspec/support/expectations.rb

@@ -1,42 +0,0 @@
-module SmartRspec
-  module Support
-    module Expectations
-      def validation_expectation(attr, value = nil, mock = nil)
-        mock ||= subject
-        mock.send("#{attr}=", value)
-
-        expect(mock).not_to be_valid
-        expect(mock).to have_error_on(attr)
-      end
-
-      def default_expectation(attr, value)
-        expect(subject.send(attr)).to eq(value)
-      end
-
-      def enum_expectation(attr, value)
-        expect(value).to include(subject.send(attr).to_sym)
-      end
-
-      def type_expectation(attr, value)
-        assert_type = value != :Boolean ? be_kind_of(Kernel.const_get(value)) : be_boolean
-        expect(subject.send(attr)).to assert_type
-      end
-
-      def has_attributes_expectation(attr, options) options.each do |key, value|
-          send("#{key}_expectation", attr, value)
-        end
-      end
-
-      def association_expectation(type, model)
-        if type == :has_many
-          expect(subject).to respond_to("#{model.to_s.singularize}_ids")
-        elsif type == :belongs_to
-          %W(#{model}= #{model}_id #{model}_id=).each do |method|
-            expect(subject).to respond_to(method)
-          end
-        end
-      end
-    end
-  end
-end
-