database_tester 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0371542429b7f8340e494939dfc0704c829824c9
+  data.tar.gz: e4277696442164a124c214baa29ff42510a3ed84
+SHA512:
+  metadata.gz: 6e282512a5e8a1622d8cc514beb8a99cce85623cfddc03792a46195f5dc6e1b5963e51824095f7bdc580dc3c87554ae9efd816f03df6622e6b032dbdf8b6a282
+  data.tar.gz: 333f478bc7f64b2cc20cee33d3090931760f9c1ce8a71fd1879feed9a3b8ecff6dc122f869a9a575b628dfac48e2fb125866c1d39248800b533fe99a90ed7b96

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.15.4

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in database_tester.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Aleksandar Zoric
+
+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,148 @@
+[![Gem Version](https://badge.fury.io/rb/database_tester.svg)](http://badge.fury.io/rb/database_tester)
+
+# Database::Tester
+
+Testing database methods made easy.
+
+The gem provides `RSpec` tests for most of the ActiveRecord methods. Tested on `MySQL`, `PostgreSQL`, `Derby` and `SpliceMachine` databases.
+
+## Installation
+
+Add this line to your application's Gemfile, under `test` group:
+
+```ruby
+group :test do
+  gem 'database_tester'
+end
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install database_tester
+
+In your `spec_helper.rb` add on top of your file:
+
+    require 'database/tester'
+
+## Usage
+
+The gem is mostly a sum of RSpes shared examples. In order to use the gem's functions, write `RSpec` using:
+
+```ruby
+let(:model) { described_class }
+subject(:item) { create model } # (You can use "let" as well)
+```
+
+- `:model` is used to test the database functions agains the model that is specified in this variable.
+
+- `:item` is the actual database record against which the tests will be run. This object is mostly automatically created within most of the tests, but it is needed for testing CRUD operations, so make sure it it initialized when testing `create`, `update` etc. methods.
+
+
+## Examples and List of Methods:
+
+```ruby
+describe Company do
+  let(:model) { described_class }
+
+  it { should have_db_column(:name).of_type(:string) }
+  it { should have_many(:users) }
+  it { should have_many(:profiles).through(:users) }
+  it { should have_one(:address) }
+
+
+  describe 'CRUD operations' do
+    subject(:item) { create model }
+
+    it_behaves_like 'model create'
+    it_behaves_like 'model update', :name, 'New Company Name'
+    it_behaves_like 'model readonly update', :description, 'Company Description'
+    it_behaves_like 'model destroy'
+    it_behaves_like 'model create_with', :name, 'New Company', :description, 'This Is A New Company'
+  end
+
+  describe 'Validation' do
+    it_behaves_like 'model validation', :name
+  end
+
+  describe 'Associations' do
+    it_behaves_like 'has_many association', User
+    it_behaves_like 'has_one association', Profile
+    it_behaves_like 'belongs_to association', Organization, true
+    it_behaves_like 'polymorphic association', :address, Address
+    it_behaves_like 'has_many through association', Profile, User
+    it_behaves_like 'habtm association', Tag
+  end
+
+  describe 'Selectors' do
+    it_behaves_like 'selector', :all_records
+    it_behaves_like 'selector', :ordered
+    it_behaves_like 'selector', :reverse_ordered
+    it_behaves_like 'selector', :limited
+    it_behaves_like 'selector', :selected
+    it_behaves_like 'selector', :grouped, group_by: :name, options: { name: 'New Name' }
+    it_behaves_like 'selector', :offsetted
+    it_behaves_like 'selector all with update', :name, { name: 'New Company' }
+    it_behaves_like 'find selector'
+    it_behaves_like 'join and include query', User
+    it_behaves_like 'distinct selector', :name
+    it_behaves_like 'eager_load selector', :users
+    it_behaves_like 'preload selector', :users
+    it_behaves_like 'references selector', :users
+    it_behaves_like 'reverse_order selector'
+    it_behaves_like 'find_by selector', :name, 'name1', 'name2'
+    it_behaves_like 'range conditions'
+    it_behaves_like 'subset conditions'
+    it_behaves_like 'find_or_create_by selector', :name, 'Company1'
+    it_behaves_like 'find_or_create_by! selector', :name, 'Company1'
+    it_behaves_like 'find_or_initialize_by selector', :name, 'Company1'
+    it_behaves_like 'select_all selector'
+    it_behaves_like 'pluck selector', :name
+    it_behaves_like 'ids selector'
+    it_behaves_like 'exists? selector', :name, 'val1', 'val2'
+    it_behaves_like 'minimum selector', :name, ['3', '5', '1', '4', '2']
+    it_behaves_like 'raw sql selector', :name, 'TestName'
+  end
+
+  describe 'Additional functions' do
+    it_behaves_like 'pessimistic locking'
+    it_behaves_like 'extending scope'
+    it_behaves_like 'none relation'
+  end
+end
+```
+
+## Testing
+
+To test the code run in your project directory:
+
+```ruby
+bundle exec rspec spec/
+```
+
+## Contributing
+
+Bug reports and pull requests are always welcome.
+
+1. Fork it ( https://github.com/aleksandaar/database_tester/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+
+## Ruby versions
+
+   Currently tested on **Ruby** `2.3.1` and **JRuby** `9.1.5.0`
+
+
+## Credits
+
+`Database Tester` is developed and maintained by [Aleksandar Zoric](https://github.com/aleksandaar "Aleksandar Zoric")
+
+## License
+
+MIT License. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "database/tester"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/database_tester.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "database/tester/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "database_tester"
+  spec.version       = Database::Tester::VERSION
+  spec.authors       = ["Aleksandar Zoric"]
+  spec.email         = ["aleksandroz.mail@gmail.com"]
+
+  spec.summary       = %q{Testing database methods made easy.}
+  spec.description   = %q{Test ActiveRecord methods against specific models in your database.}
+  spec.homepage      = "http://aleksandroz.com"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/database/tester/version.rb

@@ -0,0 +1,5 @@
+module Database
+  module Tester
+    VERSION = "1.0.0"
+  end
+end

data/lib/database/tester.rb

@@ -0,0 +1,559 @@
+require "database/tester/version"
+
+module Database
+  module Tester
+    RSpec.shared_examples 'model create' do
+      it 'is created' do
+        expect{ create(model) }.to change(model, :count).by(1)
+      end
+    end
+
+    RSpec.shared_examples 'model update' do |field, value|
+
+      it 'is updated' do
+        old_field = item.send(field)
+        expect{item.update field => value}.to change{item.send(field)}.from(old_field).to(value)
+      end
+    end
+
+    RSpec.shared_examples 'model readonly update' do |field, value|
+      before { item.update field => value }
+
+      it 'is not updated' do
+        expect(model.where(id: item.id)[0].send(field)).not_to eq value
+      end
+    end
+
+    RSpec.shared_examples 'model destroy' do
+      before { item.save }
+
+      it 'is destroyed' do
+        expect{ item.destroy }.to change(model, :count).by(-1)
+      end
+    end
+
+    RSpec.shared_examples 'model create_with' do |find_by_field, find_by_value, field, value|
+      it 'creates with value' do
+        expect{ model.create_with(field => value).find_or_create_by(find_by_field => find_by_value) }.to change(model, :count).by(1)
+        expect(model.order(id: :desc)[0][find_by_field]).to eq(find_by_value)
+      end
+
+      it 'returns an existing model' do
+        model.create!(find_by_field => find_by_value)
+        expect{ model.create_with(field => value).find_or_create_by(find_by_field => find_by_value) }.to change(model, :count).by(0)
+      end
+    end
+
+
+    RSpec.shared_examples 'model validation' do |*fields|
+      let(:new_item) { model.new }
+
+      it 'is not created if it is not valid' do
+        expect(new_item).to_not be_valid
+        fields.each do |field|
+          expect(new_item.errors[field].any?).to be_truthy
+        end
+      end
+    end
+
+    RSpec.shared_examples 'belongs_to association' do |model_associated, required = false|
+      let (:item) { create model }
+      let (:item_associated) { create model_associated }
+      let (:model_association) { model_associated.to_s.downcase }
+
+      it "adds #{model_associated}" do
+        item.send("#{model_association}=", item_associated)
+        item.save
+        expect(model.where(id: item.id)[0].send(model_association)).to eq item_associated
+      end
+
+      if required
+        it "does not remove #{model_associated}" do
+          item.send("#{model_association}=", item_associated)
+          item.save
+          item.send("#{model_association}=", nil)
+          expect(item).to_not be_valid
+        end
+      end
+    end
+
+    RSpec.shared_examples 'has_one association' do |model_associated, required = false|
+      let (:item) { create model }
+      let (:item_associated) { create model_associated }
+      let (:model_association) { model_associated.to_s.downcase }
+
+      before do
+        item.send("#{model_association}=", item_associated)
+        item.save
+      end
+
+      it "adds #{model_associated}" do
+        expect(model.where(id: item.id)[0].send(model_association)).to eq item_associated
+      end
+
+      if required
+        it "does not remove #{model_associated}" do
+          item.send("#{model_association}=", nil)
+          expect(item).to_not be_valid
+        end
+      end
+    end
+
+    RSpec.shared_examples 'has_many association' do |model_associated, required = false|
+      let (:item) { create model }
+      let (:item_associated) { create model_associated }
+      let (:model_association) { model_associated.model_name.plural }
+
+      before do
+        item.send(model_association) << item_associated
+      end
+
+      it "adds #{model_associated}" do
+        if required
+          expect(item.send(model_association).count).to eq 2
+          expect(item.send(model_association)[1]).to eq item_associated
+        else
+          expect(item.send(model_association).count).to eq 1
+          expect(item.send(model_association)[0]).to eq item_associated
+        end
+      end
+
+      it "removes #{model_associated}" do
+        item.send(model_association).delete(item_associated)
+        if required
+          expect(item.send(model_association).count).to eq 1
+          expect(item.send(model_association)[0]).to_not be_nil
+        else
+          expect(item.send(model_association).count).to eq 0
+          expect(item.send(model_association)[0]).to be_nil
+        end
+      end
+
+      it "destroys dependent #{model_associated}" do
+        item.destroy
+        expect(item.send(model_association).count).to eq 0
+        expect(item.send(model_association)[0]).to be_nil
+      end
+    end
+
+    RSpec.shared_examples 'habtm association' do |model_associated, required = false|
+      let (:item) { create model }
+      let (:item_associated) { create model_associated }
+      let (:model_association) { model_associated.model_name.plural }
+
+      it "adds #{model_associated}" do
+        item.send(model_association) << item_associated
+        if required
+          expect(item.send(model_association).count).to eq 2
+        else
+          expect(item.send(model_association).count).to eq 1
+        end
+        expect(item.send(model_association).order(id: :desc)[0]).to eq item_associated
+      end
+
+      it "creates #{model_associated}" do
+        item.send(model_association).send(:create, item_associated.attributes.except('id', 'created_at', 'updated_at'))
+        expect(item.send(model_association).count).to eq 1
+      end
+
+      it "removes #{model_associated}" do
+        item.send(model_association) << item_associated
+        item.send(model_association).delete(item_associated)
+        if required
+          expect(item.send(model_association).count).to eq 1
+          expect(item.send(model_association)[0]).to_not be_nil
+        else
+          expect(item.send(model_association).count).to eq 0
+          expect(item.send(model_association)[0]).to be_nil
+        end
+      end
+    end
+
+    RSpec.shared_examples 'has_many through association' do |model_associated, model_through|
+      let (:item) { create model }
+      let (:base_model_association) { model.to_s.downcase }
+      let (:model_association) { model_associated.to_s.downcase }
+      let (:model_association_pl) { model_associated.model_name.plural  }
+      let (:model_through_association) { model_through.to_s.downcase }
+      let (:model_through_association_pl) { model_through.model_name.plural }
+
+      let! (:item_through) { create model_through, base_model_association => item }
+      let! (:item_associated) { create model_associated, model_through_association => item_through}
+
+      it "creates #{model_associated}" do
+        expect(item.send(model_association_pl).count).to eq 1
+      end
+
+      it "deletes #{model_associated}" do
+        item.send(model_through_association_pl).send(:destroy_all)
+        expect(item.send(model_association_pl).count).to eq 0
+      end
+
+    end
+
+
+    RSpec.shared_examples 'polymorphic association' do |model_association, *models_associated|
+      let (:item) { create model }
+
+      models_associated.each do |model_associated|
+        it "has an association with #{model_associated}" do
+          item_associated = create model_associated
+          item.send "#{model_association}=", item_associated
+          expect(item.send(model_association)).to be_an(model_associated)
+        end
+      end
+    end
+
+    RSpec.shared_examples 'join and include query' do |model_associated|
+      let! (:item) { create model }
+      let (:item_associated) { create model_associated }
+      let (:model_association) { model_associated.model_name.plural }
+
+      before do
+        item.send(model_association) << item_associated
+      end
+
+      it ".joins #{model_associated}" do
+        item_relation = model.send(:where, {id: item.id})
+        item_relation.joins(model_association.downcase.to_sym).each do |item_object|
+          expect(item_object.send(model_association).count).to eq 1
+        end
+      end
+
+      it ".includes #{model_associated}" do
+        model.send(:where, {id: item.id}).includes(model_association.downcase.to_sym).each do |item_object|
+         expect(item_object.send(model_association).count).to eq 1
+        end
+      end
+    end
+
+    RSpec.shared_examples 'pessimistic locking' do
+      let (:item) { create model }
+
+      it 'locks table row' do
+        ActiveRecord::Base.transaction do
+          locked_item = model.find(item.id).lock!
+          expect(locked_item.update_attributes({})).to eq true
+        end
+      end
+    end
+
+
+    RSpec.shared_examples 'selector' do |scope_action, group_by: nil, options: {}|
+      describe ".#{scope_action}" do
+        let!(:item_1) { create model, options }
+        let!(:item_2) { create model, options}
+
+        it 'returns items' do
+          return_result = case scope_action
+          when :all_records
+            [item_1, item_2]
+          when :ordered
+            [item_2, item_1]
+          when :reverse_ordered
+            [item_1, item_2]
+          when :limited
+            [item_1]
+          when :selected
+            [item_1, item_2]
+          when :grouped
+            { item_1.send(group_by) => 2 }
+          when :having_grouped
+            { item_1.try(group_by) => 1, item_2.try(group_by) => 1 }
+          when :offsetted
+            [item_2]
+          end
+
+          result = model.send(scope_action)
+          if scope_action == :grouped || scope_action == :having_grouped
+            result = result.count
+          end
+
+          expect(result).to eq return_result
+        end
+      end
+    end
+
+    RSpec.shared_examples 'selector all with update' do |field, options = {}|
+      let!(:item_1) { create model }
+      let!(:item_2) { create model }
+
+      describe ".all after update" do
+        it 'returns item' do
+          item_2.update(options)
+          expect(model.where(id: item_2.id)[0].send(field)).to eq item_2.send(field)
+        end
+      end
+
+    end
+
+    RSpec.shared_examples 'find selector' do
+      let!(:item_1) { create model }
+      let!(:item_2) { create model }
+
+      describe ".find" do
+        it 'returns item' do
+          expect(model.send(:find, item_2.id)).to eq item_2
+        end
+      end
+
+      describe ".find array" do
+        it 'returns items' do
+          expect(model.send(:find, [item_1.id, item_2.id])).to eq [item_1, item_2]
+        end
+      end
+
+      describe ".find_in_batches" do
+        it 'returns all items' do
+          model.send(:find_in_batches) do |batch|
+            expect(batch).to eq [item_1, item_2]
+          end
+        end
+      end
+    end
+
+
+    RSpec.shared_examples 'having selector' do
+      let!(:item_1) { create model }
+      let!(:item_2) { create model }
+
+      describe ".find" do
+        it 'returns item' do
+          expect(model.send(:find, item_2.id)).to eq item_2
+        end
+      end
+
+      describe ".find array" do
+        it 'returns items' do
+          expect(model.send(:find, [item_1.id, item_2.id])).to eq [item_1, item_2]
+        end
+      end
+
+      describe ".find_in_batches" do
+        it 'returns all items' do
+          model.send(:find_in_batches) do |batch|
+            expect(batch).to eq [item_1, item_2]
+          end
+        end
+      end
+    end
+
+    RSpec.shared_examples 'distinct selector' do |field|
+      let!(:item_1) { create model, field => 1 }
+      let!(:item_2) { create model, field => 2 }
+      let!(:item_3) { create model, field => 2 }
+      let!(:item_4) { create model, field => 3 }
+
+      it "returns unique values" do
+        expect(model.select(field).distinct.map(&field).map(&:to_i).sort).to eq([1, 2, 3])
+      end
+    end
+
+    RSpec.shared_examples 'eager_load selector' do |association|
+      let!(:main_item) { create model }
+
+      before do
+        main_item.send(association).create!
+        @sub_item1 = main_item.send(association).order(id: :desc)[0]
+        main_item.send(association).create!
+        @sub_item2 = main_item.send(association).order(id: :desc)[0]
+        main_item.send(association).create!
+        @sub_item3 = main_item.send(association).order(id: :desc)[0]
+      end
+
+      it "loads the associated items" do
+        expect(model.eager_load(association).where(id: main_item.id)[0].send(association).to_a).to eq([@sub_item1, @sub_item2, @sub_item3])
+      end
+    end
+
+    RSpec.shared_examples 'extending scope' do
+      let!(:item_1) { create model }
+      let!(:item_2) { create model }
+      let!(:item_3) { create model }
+      let!(:item_4) { create model }
+      let!(:item_5) { create model }
+      let!(:item_6) { create model }
+
+      it "allows extending a scope" do
+        scope = model.all.extending do
+          def page(number)
+            per_page = 4
+            limit(per_page).offset((number - 1) * per_page)
+          end
+        end
+        expect(scope.page(2).to_a).to eq([item_5, item_6])
+      end
+    end
+
+    RSpec.shared_examples 'none relation' do |association|
+      it "returns an empty active record relation" do
+        expect(model.none.to_a).to eq([])
+      end
+    end
+
+    RSpec.shared_examples 'preload selector' do |association|
+      let!(:main_item) { create model }
+
+      before do
+        main_item.send(association).create!
+        @sub_item1 = main_item.send(association).order(id: :desc)[0]
+        main_item.send(association).create!
+        @sub_item2 = main_item.send(association).order(id: :desc)[0]
+        main_item.send(association).create!
+        @sub_item3 = main_item.send(association).order(id: :desc)[0]
+      end
+
+      it "loads the associated items" do
+        expect(model.preload(association).where(id: main_item.id)[0].send(association).to_a).to eq([@sub_item1, @sub_item2, @sub_item3])
+      end
+    end
+
+    RSpec.shared_examples 'references selector' do |association|
+      let!(:main_item) { create model }
+
+      before do
+        main_item.send(association).create!(created_at: 1.week.ago)
+        @sub_item1 = main_item.send(association).order(id: :desc)[0]
+        main_item.send(association).create!(created_at: 2.weeks.ago)
+        @sub_item2 = main_item.send(association).order(id: :desc)[0]
+        main_item.send(association).create!(created_at: 3.weeks.ago)
+        @sub_item3 = main_item.send(association).order(id: :desc)[0]
+      end
+
+      it "loads the associated items with an SQL query fragment" do
+        expect(model.includes(association).where("#{association}.created_at >= ?", 16.days.ago).references(association)[0].send(association)).to eq([@sub_item1, @sub_item2])
+      end
+    end
+
+    RSpec.shared_examples 'reverse_order selector' do
+      let!(:item1) { create model, name: 'name1' }
+      let!(:item2) { create model, name: 'name2' }
+      let!(:item3) { create model, name: 'name3' }
+
+      it "reverses the order of returned items" do
+        expect(model.order(:name).reverse_order).to eq([item3, item2, item1])
+      end
+    end
+
+    RSpec.shared_examples 'find_by selector' do |field, value1, value2|
+      let!(:item1) { create model, field => value1 }
+      let!(:item2) { create model, field => value2 }
+
+      it "returns the item with the correct value" do
+        expect(model.find_by(field => value1)).to eq(item1)
+      end
+    end
+
+    RSpec.shared_examples 'range conditions' do
+      let!(:item1) { create model, created_at: 1.day.ago }
+      let!(:item2) { create model, created_at: 2.days.ago }
+      let!(:item3) { create model, created_at: 4.days.ago }
+
+      it "returns the item with the correct value" do
+        expect(model.where(created_at: 3.days.ago..DateTime.now)).to eq([item1, item2])
+      end
+    end
+
+    RSpec.shared_examples 'subset conditions' do
+      let!(:item1) { create model, name: 'name1' }
+      let!(:item2) { create model, name: 'name2' }
+      let!(:item3) { create model, name: 'name3' }
+      let!(:item4) { create model, name: 'name4' }
+
+      it "returns the items with the correct values" do
+        expect(model.where(name: ['name1', 'name2', 'name4'])).to eq([item1, item2, item4])
+      end
+    end
+
+    RSpec.shared_examples 'find_or_create_by selector' do |field, value|
+      it "creates a new object when it doesn't exist" do
+        expect(model.find_or_create_by(field => value).send(field)).to eq(value)
+      end
+
+      it "returns an existing object" do
+        item1 = create(model, field => value)
+        expect(model.find_or_create_by(field => value)).to eq(item1)
+      end
+    end
+
+    RSpec.shared_examples 'find_or_create_by! selector' do |field, value|
+      it "creates a new object when it doesn't exist" do
+        expect(model.find_or_create_by!(field => value).send(field)).to eq(value)
+      end
+
+      it "returns an existing object" do
+        item1 = create(model, field => value)
+        expect(model.find_or_create_by!(field => value)).to eq(item1)
+      end
+    end
+
+    RSpec.shared_examples 'find_or_initialize_by selector' do |field, value|
+      it "initializes a new object when it doesn't exist" do
+        expect(model.find_or_initialize_by(field => value).attributes).to eq(model.new(field => value).attributes)
+      end
+
+      it "returns an existing object" do
+        item1 = create(model, field => value)
+        expect(model.find_or_initialize_by(field => value)).to eq(item1)
+      end
+    end
+
+    RSpec.shared_examples 'select_all selector' do
+      let!(:item) { create model }
+      it "returns an array of hashes with results from the database" do
+        expect(model.connection.select_all("SELECT * FROM #{model.table_name} WHERE id = #{item.id}").to_a[0].slice('id', 'name', 'description')).to eq({"id" => item.id, "name" => item.name, "description" => item.description})
+      end
+    end
+
+    RSpec.shared_examples 'pluck selector' do |field|
+      let!(:item1) { create model, field => 'val1' }
+      let!(:item2) { create model, field => 'val2' }
+      let!(:item3) { create model, field => 'val3' }
+
+      it "returns an array of values for the field" do
+        expect(model.pluck(field)).to eq(['val1', 'val2', 'val3'])
+      end
+    end
+
+    RSpec.shared_examples 'ids selector' do
+      let!(:item1) { create model }
+      let!(:item2) { create model }
+      let!(:item3) { create model }
+
+      it "returns an array of values for the field" do
+        expect(model.ids).to eq([item1.id, item2.id, item3.id])
+      end
+    end
+
+    RSpec.shared_examples 'exists? selector' do |field, value, other_value|
+      let!(:item) { create model, field => value }
+
+      it "returns true when object exists" do
+        expect(model.where(field => value).exists?).to eq(true)
+      end
+
+      it "returns false when object doesn't exist" do
+        expect(model.where(field => other_value).exists?).to eq(false)
+      end
+    end
+
+    RSpec.shared_examples 'minimum selector' do |field, values|
+      it "returns the minimal value for selected field" do
+        minimum = values.min
+        values.each do |value|
+          create(model, field => value)
+        end
+        expect(model.minimum(field)).to eq(minimum)
+      end
+    end
+
+    RSpec.shared_examples 'raw sql selector' do |field, value|
+      it "returns the expected results" do
+        create(model, field => value)
+        sql = "SELECT * FROM #{model.table_name} ORDER BY #{model.table_name}.id DESC FETCH NEXT 1 ROWS ONLY"
+        results = ActiveRecord::Base.connection.execute(sql)
+        expect(results[0][field.to_s]).to eq(value)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: database_tester
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Aleksandar Zoric
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-11-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !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.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Test ActiveRecord methods against specific models in your database.
+email:
+- aleksandroz.mail@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- database_tester.gemspec
+- lib/database/tester.rb
+- lib/database/tester/version.rb
+homepage: http://aleksandroz.com
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Testing database methods made easy.
+test_files: []