smart_rspec 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 56204d08a3ee3d45091216ca50b197a4d9b08095
+  data.tar.gz: dd3431e077d7ef0a94d6df2e8df66779f14c1705
+SHA512:
+  metadata.gz: b5a735e0e33fb63863c343ad17b3a5daeb0282cc759d7a1852cc2a7c734db2d69cb58cea1724548841abe331b1b1d9261eb38d0a8099a08f679c13b8c33d5be6
+  data.tar.gz: 3afea96381aeb7aed7dedf20eabd1814e07e9cb08731760deba0fd8b10aef4de2447f41f4244b45e35445264107a1377763584badc84cd5ad903247ed12db72b

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.sw*
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in smart_rspec.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Tiago Guedes
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,206 @@
+# SmartRspec
+
+It's time to make your specs even more awesome! SmartRspec adds useful macros and matchers into the RSpec's test suite, this way you can quickly define specs for your Rails app and get focused on making things turn into green.
+
+## Installation
+
+Compatible with Ruby 1.9+
+
+Add this line to your application's Gemfile:
+
+    gem 'smart_rspec'
+
+Execute:
+
+    $ bundle
+
+Require the gem at the top of your `spec/rails_helper.rb` (or equivalent):
+``` ruby 
+require 'smart_rspec'
+```
+
+Then include the SmartRspec module:
+
+``` ruby 
+RSpec.configure do |config|
+  config.include SmartRspec
+end
+```
+
+## Usage
+
+* [Macros](#macros)
+    * [has_attributes](#has_attributes)
+    * [belongs_to, has_one, has_many](#belongs_to-has_one-has_many)
+    * [fails_validation_of](#fails_validation_of)
+* [Matchers](#matchers)
+  * [be_ascending](#be_ascending)
+  * [be_descending](#be_descending)
+  * [be_boolean](#be_boolean)
+  * [be_email](#be_email)
+  * [be_url](#be_url)
+  * [be_image_url](#be_image_url)
+  * [have](#have)
+  * [have_at_least](#have_at_least)
+  * [have_at_most](#have_at_most)
+  * [have_error_on](#have_error_on)
+  * [include_items](#include_items)
+
+### Macros
+
+You will just need to define a valid `subject` to start using SmartRspec's macros in your spec file.
+
+#### has_attributes
+
+It builds specs for model attributes and test its type, enumerated values and defaults:
+``` ruby
+RSpec.describe User, type: :model do
+    subject { FactoryGirl.build(:user) }
+    
+    has_attributes :email, type: :String
+    has_attributes :is_admin, type: :Boolean
+    has_attributes :score, type: :Integer, default: 0
+    has_attributes :locale, type: :String, enum: %i(en pt), default: 'en'
+end
+```
+
+#### belongs_to, has_one, has_many
+
+It builds specs and test model associations like `belongs_to`, `has_one` and `has_many`.
+``` ruby
+RSpec.describe User, type: :model do
+    subject { FactoryGirl.build(:user) }
+    
+    belongs_to :business
+    has_one :project
+    has_many :tasks
+end
+```
+
+#### fails_validation_of 
+
+It builds specs forcing model validations to fail, it means that you will only turn its specs into green when you specify the corresponding validation in the model.
+
+``` ruby
+RSpec.describe User, type: :model do
+    subject { FactoryGirl.build(:user) }
+    
+    fails_validation_of :email, presence: true, email: true
+    fails_validation_of :name, length: { maximum: 80 }, uniqueness: true
+    fails_validation_of :username, length: { minimum: 10 }, exclusion: { in: %w(foo bar) }
+    # Other validations...
+end
+```
+
+The `fails_validation_of` implements specs for the following validations:
+
+- `presence`
+- `email`
+- `length`
+- `exclusion`
+- `inclusion`
+- `uniqueness`
+- `format`
+
+In two cases it will require a valid mock to be passed so SmartRspec can use it to force the validation to fail properly.
+
+For uniqueness with scope:
+``` ruby
+  other_user = FactoryGirl.build(:other_valid_user)
+  fails_validation_of :username, uniqueness: { scope: :name, mock: other_user }
+```
+
+For format:
+``` ruby
+fails_validation_of :foo, format: { with: /foo/, mock: 'bar' }
+```
+
+### Matchers
+
+SmartRspec gathers a collection of custom useful matchers:
+
+#### be_ascending
+
+``` ruby
+it { expect([1, 2, 3, 4]).to be_ascending }
+it { expect([1, 4, 2, 3]).not_to be_ascending }
+```
+
+#### be_descending
+``` ruby
+it { expect([4, 3, 2, 1]).to be_descending }
+it { expect([1, 2, 3, 4]).not_to be_descending }
+```
+
+#### be_boolean
+``` ruby
+it { expect(true).to be_boolean }
+it { expect('true').not_to be_boolean }
+```
+
+#### be_email
+``` ruby
+it { expect('tiagopog@gmail.com').to be_email }
+it { expect('tiagopog@gmail').not_to be_email }
+```
+
+#### be_url
+``` ruby
+it { expect('http://adtangerine.com').to be_url }
+it { expect('adtangerine.com').not_to be_url }
+```
+
+#### be_image_url
+``` ruby
+it { expect('http://adtangerine.com/foobar.png').to be_image_url }
+it { expect('http://adtangerine.com/foobar.jpg').not_to be_image_url(:gif) }
+it { expect('http://adtangerine.com/foo/bar').not_to be_image_url }
+```
+
+#### have(x).items
+``` ruby
+it { expect([1]).to have(1).item }
+it { expect(%w(foo bar)).to have(2).items }
+it { expect(%w(foo bar)).not_to have(1).item }
+```
+
+#### have_at_least
+``` ruby
+it { expect(%w(foo bar foobar)).to have_at_least(3).items }
+```
+
+#### have_at_most
+``` ruby
+it { expect(%w(foo bar foobar)).to have_at_most(3).items }
+```
+#### have_error_on
+``` ruby
+subject(:user) { FactoryGirl.build(:user, email: nil) }
+
+it 'has an invalid email' do
+    user.valid?
+    expect(user).to have_error_on(:email)
+    expect(user).not_to have_error_on(:email)
+end
+```
+
+#### include_items
+``` ruby
+it { expect(%w(foo bar foobar)).to include_items(%w(foo bar foobar)) }
+```
+
+# TODO
+
+- Create macros for model scopes;
+- Create macros for controllers and requests;
+- Add more matchers.
+
+## Contributing
+
+1. Fork it;
+2. Create your feature branch (`git checkout -b my-new-feature`);
+3. Create your specs and make sure they are passing;
+4. Document your feature in the README.md;
+4. Commit your changes (`git commit -am 'Add some feature'`);
+5. Push to the branch (`git push origin my-new-feature`);
+6. Create new Pull Request.

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/smart_rspec/macros.rb

@@ -0,0 +1,34 @@
+require 'smart_rspec/support/assertions'
+
+module SmartRspec::Macros
+  include SmartRspec::Support::Assertions
+
+  def belongs_to(*associations)
+    assert_association :belongs_to, associations
+  end
+
+  def has_attributes(*attrs)
+    options = attrs.last.is_a?(Hash) && attrs.last.has_key?(:type) ? attrs.pop : nil
+    assert_has_attributes(attrs, options)
+  end
+
+  def has_one(*associations)
+    assert_association :has_one, associations
+  end
+
+  def has_many(*associations)
+    assert_association :has_many, associations
+  end
+
+  def fails_validation_of(*attrs, validations)
+    attrs.each do |attr|
+      context attr do
+        validations.keys.each do |key|
+          validation = validations[key]
+          validation && send("validates_#{key}_of", attr, validation)
+        end
+      end
+    end
+  end
+end
+

data/lib/smart_rspec/matchers.rb

@@ -0,0 +1,45 @@
+require 'rspec/matchers'
+require 'rspec/expectations'
+require 'rspec/collection_matchers'
+require 'smart_rspec/support/regexes'
+
+include SmartRspec::Support::Regexes
+
+module SmartRspec
+  module Matchers
+    extend RSpec::Matchers::DSL
+
+    matcher :be_boolean do
+      match { |actual| [true, false].include?(actual) }
+    end
+
+    matcher :be_email do
+      match { |actual| actual =~ build_regex(:email) }
+    end
+
+    matcher :be_url do
+      match { |actual| actual =~ build_regex(:uri) }
+    end
+
+    matcher :be_image_url do |*types|
+      match { |actual| actual =~ build_regex(:image, types) }
+    end
+
+    matcher :have_error_on do |attr|
+      match { |actual| actual.errors.keys.include?(attr) }
+    end
+
+    matcher :include_items do |*items|
+      match { |actual| (items.flatten - [actual].flatten).empty? }
+    end
+
+    matcher :be_ascending do
+      match { |actual| actual == actual.sort  }
+    end
+
+    matcher :be_descending do
+      match { |actual| actual.each_cons(2).all? { |i, j| i >= j  } }
+    end
+  end
+end
+

data/lib/smart_rspec/support/assertions.rb

@@ -0,0 +1,125 @@
+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|
+            assert_validation(attr, e)
+          end
+        end
+      end
+
+      def validates_exclusion_of(attr, validation)
+        it 'has a reserved value' do
+          assert_validation(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
+            assert_validation(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)
+          assert_validation(attr, value)
+        end
+      end
+
+      def validates_length_of(attr, validation)
+        validation.each do |key, value|
+          next unless %i(in is maximum minimum within).include?(key)
+          txt, n = build_length_validation(key, value)
+          it txt do
+            assert_validation(attr, 'x' * n)
+          end
+        end
+      end
+
+      def validates_presence_of(attr, validation)
+        it 'is blank' do
+          assert_validation(attr, nil)
+        end
+      end
+
+      def validates_uniqueness_of(attr, validation)
+        scoped = scoped_validation?(validation)
+        scope = scoped ? validation[:scope] : nil
+
+        it "is already in use#{" (scope: #{scope})" if scoped}" do
+          mock = (validation[:mock] rescue nil) || subject.dup
+          scoped && mock.send("#{scope}=", subject.send(scope))
+
+          assert_validation(attr, subject.send(attr), mock)
+        end
+      end
+
+      def assert_has_attributes(attrs, options)
+        type_str = build_type_str(options)
+        default, enum, type = options.values_at(:default, :enum, :type)
+
+        attrs.each do |attr|
+          it %Q(has an attribute named "#{attr}"#{type_str}) do
+            expect(subject).to respond_to(attr)
+            default && (expect(subject.send(attr)).to eq(default))
+            enum && (expect(enum).to include(subject.send(attr).to_sym))
+            type && assert_attr_type(attr, type, options)
+          end
+        end
+      end
+
+      def assert_association(assoc_type, associations)
+        associations.each do |association|
+          it "#{assoc_type.to_s.gsub('_', ' ')} #{association}" do
+            expect(subject).to respond_to(association)
+            case assoc_type
+            when :belongs_to
+              %W(#{association}= #{association}_id #{association}_id=).each do |method|
+                expect(subject).to respond_to(method)
+              end
+            when :has_many
+              expect(subject).to respond_to("#{association.to_s.singularize}_ids")
+            end
+          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) && (%i(scope mock) - validation.keys).empty?
+      end
+    end
+  end
+end
+

data/lib/smart_rspec/support/expectations.rb

@@ -0,0 +1,19 @@
+module SmartRspec
+  module Support
+    module Expectations
+      def assert_attr_type(attr, type, other)
+        assert_type = type == :Boolean ? be_boolean : be_kind_of(Kernel.const_get(type))
+        expect(subject.send(attr)).to assert_type
+      end
+
+      def assert_validation(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
+    end
+  end
+end
+

data/lib/smart_rspec/support/regexes.rb

@@ -0,0 +1,44 @@
+module SmartRspec
+  module Support
+    module Regexes
+      def build_regex(type, *args)
+        type = type.to_sym unless type.is_a? Symbol
+        case type
+        when :email
+          /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i
+        when :image
+          build_img_regex(args.flatten)
+        else
+          build_uri_regex[type]
+        end
+      end
+
+      private_class_method
+
+      def build_img_regex(exts = [])
+        exts = [exts].flatten unless exts.is_a?(Array)
+        if exts.nil? || exts.empty?
+          exts = %w(jpg jpeg png gif)
+        elsif exts.include?(:jpg) && !exts.include?(:jpeg)
+          exts.push :jpeg
+        end
+        %r{(^http{1}[s]?://([w]{3}\.)?.+\.(#{exts.join('|')})(\?.+)?$)}i
+      end
+
+      def build_uri_regex
+        {
+          uri: %r{^(
+                (((ht|f)tp[s]?://)|([a-z0-9]+\.))+
+                (?<!@)
+                ([a-z0-9\_\-]+)
+                (\.[a-z]+)+
+                ([\?/\:][a-z0-9_=%&@\?\./\-\:\#\(\)]+)?
+                /?
+              )$}ix,
+          protocol: /((ht|f)tp[s]?)/i
+        }
+      end
+    end
+  end
+end
+

data/lib/smart_rspec/version.rb

@@ -0,0 +1,3 @@
+module SmartRspec
+  VERSION = '0.0.1'
+end

data/lib/smart_rspec.rb

@@ -0,0 +1,19 @@
+require 'active_support/concern'
+require 'smart_rspec/macros'
+require 'smart_rspec/matchers'
+require 'smart_rspec/support/expectations'
+
+include SmartRspec::Matchers
+
+module SmartRspec
+  extend ActiveSupport::Concern
+
+  included do
+    include SmartRspec::Support::Expectations
+  end
+
+  module ClassMethods
+    include SmartRspec::Macros
+  end
+end
+

data/smart_rspec.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'smart_rspec/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'smart_rspec'
+  spec.version       = SmartRspec::VERSION
+  spec.authors       = ['Tiago Guedes']
+  spec.email         = ['tiagopog@gmail.com']
+  spec.summary       = %q{Macros and matchers to make your RSpec tests even more amazing.}
+  spec.description   = %q{Collection of useful macros and matchers for RSpec tests of models/controllers in Rails-based apps.}
+  spec.homepage      = 'https://github.com/tiagopog/smart_rspec'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'activesupport', '~> 4.1'
+  spec.add_runtime_dependency 'rspec-collection_matchers', '~> 1.1', '>= 1.1.2'
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'faker', '~> 1.4'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.2'
+end

data/spec/factories/user.rb

@@ -0,0 +1,88 @@
+require 'smart_rspec/support/regexes'
+
+module Factories
+  class User
+    include SmartRspec::Support::Regexes
+
+    @@last_id = 0
+    @@collection = []
+    @@error_message = {
+      blank: "can't be blank",
+      exclusion: "can't use a reserved value",
+      format: "doesn't match the required pattern",
+      inclusion: 'value not included',
+      too_big: "can't be greater than 80 chars",
+      uniqueness: 'must be unique within the given scope'
+    }
+
+    attr_accessor :email, :system, :system_id, :project, :project_id,
+                  :name, :username, :is_admin, :score, :admin, :father,
+                  :mother, :articles, :rates
+
+    attr_reader :id, :errors
+
+    def initialize(attrs = {})
+      attrs.each { |key, value| self.send("#{key}=", value) }
+      set_defaults
+      @@collection << self
+    end
+
+    class << self
+      attr_reader :collection
+    end
+
+    def locale
+      @locale.to_s unless @locale.nil?
+    end
+
+    def locale=(locale)
+      %i(en pt).include?(locale) && @locale = locale
+    end
+
+    def valid?
+      %w(email father locale name username).each { |e| send("check_#{e}") }
+      @errors.nil?
+    end
+
+    private
+
+    def check_email
+      if !email || (email && email !~ build_regex(:email))
+        @errors.merge!({ email: @@error_message[:blank] })
+      end
+    end
+
+    def check_father
+      if father && father !~ /foo/ 
+        @errors.merge!({ father: @@error_message[:format] })
+      end
+    end
+
+    def check_locale
+      unless %i(en pt).include?(locale)
+        @errors.merge!({ locale: @@error_message[:inclusion] })
+      end
+    end
+
+    def check_name
+      if !name || (name && name.length > 80)
+        @errors.merge!({ name: @@error_message[(name ? :too_big : :blank)] })
+      end
+    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] })
+      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
+    end
+  end
+end
+

data/spec/smart_rspec/macros_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe SmartRspec::Macros do
+  include SmartRspec
+
+  before(:all) do
+    attrs = {
+      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
+    end
+
+    context 'when it receives multiple args' do
+      belongs_to :system, :project
+    end
+  end
+
+  describe '#has_attributes' do
+    context 'when it receives a single arg' do
+      has_attributes :email, :name, :username, type: :String
+      has_attributes :is_admin, type: :Boolean
+      has_attributes :score, type: :Integer, default: 0
+      has_attributes :locale, type: :String, enum: %i(en pt), default: 'en'
+    end
+
+    context 'when it receives multiple args' do
+      has_attributes :name, :username, type: :String
+    end
+  end
+
+  describe '#has_one' do
+    context 'when it receives a single arg' do
+      has_one :admin
+    end
+
+    context 'when it receives multiple args' do
+      has_one :admin, :father, :mother
+    end
+  end
+
+  describe '#has_many' do
+    context 'when it receives a single arg' do
+      has_one :articles
+    end
+
+    context 'when it receives multiple args' do
+      has_one :articles, :rates
+    end
+  end
+
+  describe '#fails_validation_of' do
+    context 'when it receives a single arg' do
+      user = User.new(email: Faker::Internet.email)
+
+      fails_validation_of :email, presence: true, email: true
+      fails_validation_of :name, length: { maximum: 80 }
+      fails_validation_of :username, uniqueness: { scope: :name, mock: 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
+
+    context 'when it receives multiple args' do
+      fails_validation_of :email, :name, presence: true
+    end
+  end
+end
+

data/spec/smart_rspec/matchers_spec.rb

@@ -0,0 +1,144 @@
+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
+
+    context 'when invalid' do
+      it { expect([1, 4, 2, 3]).not_to be_ascending }
+    end
+  end
+
+  describe '#be_boolean' do
+    context 'when valid' 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 }
+    end
+  end
+
+  describe '#be_descending' do
+    context 'when valid' 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 }
+    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
+
+    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 }
+    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
+
+    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 }
+    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(%i(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(%i(jpg png)) }
+    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
+
+    context 'when invalid' do
+      it { expect([1]).not_to have(2).items }
+      it { expect(%w(foo bar)).not_to have(1).item }
+    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 '#have_at_most' do
+    context 'when valid' do
+      it { expect(%w(foo bar foobar)).to have_at_most(3).items }
+    end
+  end
+
+  describe '#have_error_on' do
+    subject(:mock) { User.new(email: nil) }
+
+    context 'when valid' do
+      it do
+        mock.valid?
+        expect(mock).to have_error_on(:email)
+      end
+    end
+
+    context 'when invalid' do
+      it do
+        mock.email = Faker::Internet.email
+        mock.valid?
+
+        expect(mock).not_to have_error_on(:email)
+      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([1, 'foo', ['bar']]).to include_items([1, 'foo', ['bar']]) }
+    end
+
+    context 'when invalid' do
+      it { expect(%w(foo bar foobar)).not_to include_items(%w(lorem)) }
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'bundler/setup'
+require 'rubygems'
+require 'smart_rspec'
+require 'faker'
+require 'factories/user'
+
+include Factories
+

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: smart_rspec
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tiago Guedes
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: rspec-collection_matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: Collection of useful macros and matchers for RSpec tests of models/controllers
+  in Rails-based apps.
+email:
+- tiagopog@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/smart_rspec.rb
+- lib/smart_rspec/macros.rb
+- lib/smart_rspec/matchers.rb
+- lib/smart_rspec/support/assertions.rb
+- lib/smart_rspec/support/expectations.rb
+- lib/smart_rspec/support/regexes.rb
+- lib/smart_rspec/version.rb
+- smart_rspec.gemspec
+- spec/factories/user.rb
+- spec/smart_rspec/macros_spec.rb
+- spec/smart_rspec/matchers_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/tiagopog/smart_rspec
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Macros and matchers to make your RSpec tests even more amazing.
+test_files:
+- spec/factories/user.rb
+- spec/smart_rspec/macros_spec.rb
+- spec/smart_rspec/matchers_spec.rb
+- spec/spec_helper.rb