smart_rspec 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2ff36ef01dd0d51c6bab2614a6613201973dd7c7
-  data.tar.gz: cdf57909342d77f99b5ccf3b0fe3766343da5591
+  metadata.gz: 7b6913c78ea542aba3c5bb09a26bbb2b5aaa8767
+  data.tar.gz: 7a94b954a2e829efa220e487f94f3eb94894bdc1
 SHA512:
-  metadata.gz: 8e1f3afcc473a3fb8b25a21da76bbc6a4cbfd09d7e93746f15b3e224f8b4f24f438f42266906e99e4389e9ffde7f07311790d16133d2e892117f11efc22f3e72
-  data.tar.gz: ec5b1078402f12aa22cd125eceef70a1ea96ce4d639186c20505733dc7045d9a9e2be90b5f9abc4571c78ec54480a42bbd12e32994084596948835f13a4a7fbe
+  metadata.gz: 57e4f5b9b6cb2b9d55aa42c8d6e4cbdace08b94c0ae36cbcd311d74f8569dc0c88b842e42be6b362bcf087e2a9e486ab2b944d9b29bdda5ecb79774d7ada7c65
+  data.tar.gz: ebc06947e17c4c84aa5c0ba1f788dcc4f77ab6e3f09804b210694fda390f0667b627bd25ab47a130d458c5c6d58f727161ade7abeef039694d81ed8a121294f4

data/README.md

@@ -51,7 +51,6 @@ end
     * [be_a_list_of](#be_a_list_of)
     * [be_ascending](#be_ascending)
     * [be_descending](#be_descending)
-    * [be_a_bad_request](#be_a_bad_request)
   * ["Have" matchers](#have-matchers)
     * [have](#have)
     * [have_at_least](#have_at_least)
@@ -180,20 +179,6 @@ it { expect([4, 3, 2, 1]).to be_descending }
 it { expect([1, 2, 3, 4]).not_to be_descending }
 ```
 
-##### be_a_bad_request
-``` ruby
-context 'unauthenticated' do
-  subject { get :profile }
-  it { is_expected.to be_a_bad_request }
-end
-
-context 'authenticated' do
-  before { sign_in user }
-  subject { get :profile }
-  it { is_expected.to_not be_a_bad_request }
-end
-```
-
 #### Have matchers
 
 ##### have(x).items

data/lib/smart_rspec/macros.rb

@@ -1,7 +1,7 @@
-require 'smart_rspec/support/assertions'
+require 'smart_rspec/support/model/assertions'
 
 module SmartRspec::Macros
-  include SmartRspec::Support::Assertions
+  include SmartRspec::Support::Model::Assertions
 
   def belongs_to(*associations)
     assert_association :belongs_to, associations
@@ -31,4 +31,3 @@ module SmartRspec::Macros
     end
   end
 end
-

data/lib/smart_rspec/matchers/be_matchers.rb

@@ -7,12 +7,6 @@ module SmartRspec
         match { |actual| actual == actual.sort  }
       end
 
-      matcher :be_a_bad_request do
-        match do |response|
-          response.code.to_s =~ /^4/
-        end
-      end
-
       matcher :be_a_list_of do |klass|
         match do |collection|
           collection.all? { |e| e.is_a?(klass) }

data/lib/smart_rspec/matchers/json_api_matchers.rb

@@ -0,0 +1,43 @@
+module SmartRspec
+  module Matchers
+    module JsonApiMatchers
+      extend RSpec::Matchers::DSL
+      include SmartRspec::Support::Controller::Response
+
+      matcher :have_primary_data do |expected|
+        match do |response|
+          json(response).collection.all? do |record|
+            !record['id'].to_s.empty? && record['type'] == expected
+          end
+        end
+      end
+
+      matcher :have_data_attributes do |fields|
+        match do |response|
+          json(response).check_keys_in('attributes', fields)
+        end
+      end
+
+      matcher :have_relationships do |relationships|
+        match do |response|
+          json(response).check_keys_in('relationships', relationships)
+        end
+      end
+
+      matcher :have_included_relationships do
+        match do |response|
+          json(response)
+          return false if included_data.empty? || relationship_data.empty?
+          included_data.size == relationship_data.size &&
+            (included_data - relationship_data).empty?
+        end
+      end
+
+      matcher :have_meta_record_count do |count|
+        match do |response|
+          json(response).meta_record_count == count
+        end
+      end
+    end
+  end
+end

data/lib/smart_rspec/matchers/other_matchers.rb

@@ -13,4 +13,3 @@ module SmartRspec
     end
   end
 end
-

data/lib/smart_rspec/matchers.rb

@@ -1,12 +1,14 @@
 require 'smart_rspec/support/regexes'
+require 'smart_rspec/support/controller/response'
 require 'smart_rspec/matchers/be_matchers'
+require 'smart_rspec/matchers/json_api_matchers'
 require 'smart_rspec/matchers/other_matchers'
 
 module SmartRspec
   module Matchers
     include SmartRspec::Support::Regexes
     include SmartRspec::Matchers::BeMatchers
+    include SmartRspec::Matchers::JsonApiMatchers
     include SmartRspec::Matchers::OtherMatchers
   end
 end
-

data/lib/smart_rspec/support/controller/response.rb

@@ -0,0 +1,47 @@
+require 'json'
+
+module SmartRspec
+  module Support
+    module Controller
+      module Response
+        def json(response)
+          @json ||= JSON.parse(response.body)
+          self
+        end
+
+        def error
+          @error ||= @json['errors'].first
+        end
+
+        def collection
+          @collection ||= [@json['data']].flatten
+        end
+
+        def meta_record_count
+          @json['meta']['record_count']
+        end
+
+        def relationship_data
+          @relationship_data ||= collection.flat_map do |record|
+            record['relationships'].flat_map do |_, relation|
+              [relation['data']].flatten.map { |data| data.slice('type', 'id') }
+            end.compact
+          end
+        end
+
+        def included_data
+          return [] if @json['included'].nil?
+          @included_data ||= @json['included'].flat_map do |record|
+            record.slice('type', 'id')
+          end
+        end
+
+        def check_keys_in(member, keys)
+          collection.all? do |record|
+            record[member].keys.sort == keys.sort
+          end
+        end
+      end
+    end
+  end
+end

data/lib/smart_rspec/support/model/assertions.rb

@@ -0,0 +1,112 @@
+module SmartRspec
+  module Support
+    module Model
+      module Assertions
+        def validates_email_of(attr, validation)
+          it 'has an invalid format' do
+            %w(foobar foobar@ @foobar foo@bar).each do |e|
+              be_valid_expectation(attr, e, subject.dup)
+            end
+          end
+        end
+
+        def validates_exclusion_of(attr, validation)
+          it 'has a reserved value' do
+            be_valid_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
+              be_valid_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)
+            be_valid_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
+              be_valid_expectation(attr, 'x' * n)
+            end
+          end
+        end
+
+        def validates_presence_of(attr, validation)
+          it 'is blank' do
+            be_valid_expectation(attr, nil, subject.dup)
+          end
+        end
+
+        def validates_uniqueness_of(attr, validation)
+          it 'is already in use' do
+            if !validation.is_a?(Hash) || !validation.has_key?(:mock)
+              raise ArgumentError, 'A "mock" must be set when validating the uniqueness of a record'
+            elsif subject.persisted? || subject.save
+              mock, scope = validation.values_at(:mock, :scope)
+              mock.send("#{scope}=", subject.send(scope)) unless scope.to_s.empty?
+              be_valid_expectation(attr, subject.send(attr), mock)
+            end
+          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
+end

data/lib/smart_rspec/support/model/expectations.rb

@@ -0,0 +1,43 @@
+module SmartRspec
+  module Support
+    module Model
+      module Expectations
+        def be_valid_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
+end

data/lib/smart_rspec/version.rb

@@ -1,3 +1,3 @@
 module SmartRspec
-  VERSION = '0.1.3'
+  VERSION = '0.1.4'
 end

data/lib/smart_rspec.rb

@@ -2,7 +2,7 @@ require 'active_support/concern'
 require 'rspec/collection_matchers'
 require 'rspec/matchers'
 
-%w(macros matchers support/expectations).each { |f| require "smart_rspec/#{f}" }
+%w(macros matchers support/model/expectations).each { |f| require "smart_rspec/#{f}" }
 
 include SmartRspec::Matchers
 
@@ -10,11 +10,10 @@ module SmartRspec
   extend ActiveSupport::Concern
 
   included do
-    include SmartRspec::Support::Expectations
+    include SmartRspec::Support::Model::Expectations
   end
 
   module ClassMethods
     include SmartRspec::Macros
   end
 end
-

data/spec/fixtures/response.rb

@@ -0,0 +1,11 @@
+module Fixtures
+  class Response
+    def initialize
+      @file = File.read('spec/fixtures/users.json')
+    end
+
+    def body
+      @file
+    end
+  end
+end

data/spec/{factories → fixtures}/user.rb

@@ -1,6 +1,6 @@
 require 'smart_rspec/support/regexes'
 
-module Factories
+module Fixtures
   class User
     include SmartRspec::Support::Regexes
 
@@ -17,30 +17,42 @@ module Factories
 
     attr_accessor :email, :system, :system_id, :project, :project_id,
                   :name, :username, :is_admin, :score, :admin, :father,
-                  :mother, :articles, :rates
+                  :mother, :articles, :rates, :errors
 
-    attr_reader :id, :errors
+    attr_reader :id
+
+    attr_writer :locale
 
     def initialize(attrs = {})
       attrs.each { |key, value| self.send("#{key}=", value) }
       set_defaults
-      @@collection << self
     end
 
     class << self
       attr_reader :collection
+
+      def create(attrs)
+        user = User.new(attrs)
+        @@collection << user && user
+      end
+
+      def find_by(key, value)
+        @@collection.find { |e| e.send(key) == value }
+      end
+    end
+
+    def save
+      @@collection << self
     end
 
     def locale
       @locale.to_s unless @locale.nil?
     end
 
-    def locale=(locale)
-      [:en, :pt].include?(locale) && @locale = locale
+    def persisted?
+      User.find_by(:id, id)
     end
 
-    def persisted?; true end
-
     def valid?
       %w(email father locale name username).each { |e| send("check_#{e}") }
       @errors.nil?
@@ -51,6 +63,8 @@ module Factories
     def check_email
       if !email || (email && email !~ build_regex(:email))
         @errors.merge!({ email: @@error_message[:blank] })
+      elsif User.find_by(:email, email)
+        @errors.merge!({ email: @@error_message[:uniqueness] })
       end
     end
 
@@ -61,7 +75,7 @@ module Factories
     end
 
     def check_locale
-      unless [:en, :pt].include?(locale)
+      unless %w(en pt).include?(locale)
         @errors.merge!({ locale: @@error_message[:inclusion] })
       end
     end
@@ -73,18 +87,19 @@ module Factories
     end
 
     def check_username
-      other_user = @@collection.select { |e| e.name == name && e.username == username && e.id != id }.first
-      if username && (other_user || %w(foo bar).include?(username))
-        @errors.merge!({ username: @@error_message[other_user ? :uniqueness : :exclusion] })
+      if username.to_s.empty?
+        @errors.merge!({ username: @@error_message[:blank] })
+      elsif %w(foo bar).include?(username)
+        @errors.merge!({ username: @@error_message[:exclusion] })
+      elsif User.find_by(:username, username)
+        @errors.merge!({ username: @@error_message[:uniqueness] })
       end
     end
 
     def set_defaults
       @@last_id = @id = @@last_id + 1
-      { errors: {}, is_admin: false, score: 0, locale: :en }.each do |key, value|
-        eval "@#{key} ||= #{value.inspect}"
-      end
+      attrs = { errors: {}, is_admin: false, score: 0, locale: :en }
+      attrs.each { |key, value| send("#{key}=", value) }
     end
   end
 end
-

data/spec/fixtures/users.json

@@ -0,0 +1,81 @@
+{
+  "data": [
+    {
+      "id": "1",
+      "type": "users",
+      "links": {
+        "self": "http://api.myawesomesite.com/users/1"
+      },
+      "attributes": {
+        "first_name": "Tiago",
+        "last_name": "Guedes",
+        "full_name": "Tiago Guedes",
+        "birthday": "1988-22-12"
+      },
+      "relationships": {
+        "posts": {
+          "links": {
+            "self": "http://api.myawesomesite.com/users/1/relationships/posts",
+            "related": "http://api.myawesomesite.com/users/1/posts"
+          },
+          "data": [
+            {
+              "type": "posts",
+              "id": "1"
+            }
+          ]
+        }
+      }
+    },
+    {
+      "id": "2",
+      "type": "users",
+      "links": {
+        "self": "http://api.myawesomesite.com/users/2"
+      },
+      "attributes": {
+        "first_name": "Douglas",
+        "last_name": "André",
+        "full_name": "Douglas André",
+        "birthday": null
+      },
+      "relationships": {
+        "posts": {
+          "links": {
+            "self": "http://api.myawesomesite.com/users/2/relationships/posts",
+            "related": "http://api.myawesomesite.com/users/2/posts"
+          },
+          "data": []
+        }
+      }
+    }
+  ],
+  "included": [
+    {
+      "id": "1",
+      "type": "posts",
+      "links": {
+        "self": "http://api.myawesomesite.com/posts/1"
+      },
+      "attributes": {
+        "title": "An awesome post",
+        "body": "Lorem ipsum dolot sit amet"
+      },
+      "relationships": {
+        "author": {
+          "links": {
+            "self": "http://api.myawesomesite.com/posts/1/relationships/author",
+            "related": "http://api.myawesomesite.com/posts/1/author"
+          }
+        }
+      }
+    }
+  ],
+  "meta": {
+    "record_count": 2
+  },
+  "links": {
+    "first": "http://api.myawesomesite.com/users?include=posts&page%5Blimit%5D=2&page%5Boffset%5D=0",
+    "last": "http://api.myawesomesite.com/users?include=posts&page%5Blimit%5D=2&page%5Boffset%5D=0"
+  }
+}

data/spec/smart_rspec/macros_spec.rb

@@ -3,17 +3,14 @@ require 'spec_helper'
 describe SmartRspec::Macros do
   include SmartRspec
 
-  before(:all) do
-    attrs = {
-      email: Faker::Internet.email,
-      name: Faker::Name.name,
+  subject(:user) do
+    User.create({
+      email:    Faker::Internet.email,
+      name:     Faker::Name.name,
       username: Faker::Internet.user_name
-    }
-    @user = User.new(attrs)
+    })
   end
 
-  subject { @user }
-
   describe '#belongs_to' do
     context 'when it receives a single arg' do
       belongs_to :system
@@ -59,11 +56,16 @@ describe SmartRspec::Macros do
 
   describe '#fails_validation_of' do
     context 'when it receives a single arg' do
-      user = User.new(email: Faker::Internet.email)
+      new_user =
+        User.new({
+          email:    Faker::Internet.email,
+          name:     Faker::Name.name,
+          username: Faker::Internet.user_name
+        })
 
-      fails_validation_of :email, presence: true, email: true, uniqueness: true
+      fails_validation_of :email, presence: true, email: true, uniqueness: { mock: new_user }
       fails_validation_of :name, length: { maximum: 80 }
-      fails_validation_of :username, uniqueness: { scope: :name, mock: user }, exclusion: { in: %w(foo bar) }
+      fails_validation_of :username, uniqueness: { mock: new_user }, exclusion: { in: %w(foo bar) }
       fails_validation_of :locale, inclusion: { in: %w(en pt) }
       fails_validation_of :father, format: { with: /foo/, mock: 'bar' }
     end
@@ -73,4 +75,3 @@ describe SmartRspec::Macros do
     end
   end
 end
-

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.1.4
 platform: ruby
 authors:
 - Tiago Guedes
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-13 00:00:00.000000000 Z
+date: 2016-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -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
@@ -149,12 +153,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.6.2
 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
-