n_plus_one_control 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c24a275d72a208eda2b17b7eb6200eead0dc372a
+  data.tar.gz: 711bccd2b8d3cd2ebc337a8d9ebfd407933be10d
+SHA512:
+  metadata.gz: e35efece4fd758e688bf3d294b26a7071e8d38a2ecfcda7fa3942130398a1578d8c539da171afb529dd4259fff692d42433197169c99b89dc2f12318a53efe7c
+  data.tar.gz: 83403b68d17b11f8c5261045d599ea64e5e33e1c1e7f4c1d1db345a12ef0b36dd3543866485e601e364a164104c678594b5452188d983fe5208d4e6499b8b8c3

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

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

data/.rubocop.yml

@@ -0,0 +1,71 @@
+AllCops:
+  Include:
+    - 'lib/**/*.rb'
+    - 'lib/**/*.rake'
+    - 'spec/**/*.rb'
+  Exclude:
+    - 'bin/**/*'
+    - 'spec/dummy/**/*'
+    - 'tmp/**/*'
+    - 'Rakefile'
+    - 'Gemfile'
+    - '*.gemspec'
+  DisplayCopNames: true
+  StyleGuideCopsOnly: false
+  TargetRubyVersion: 2.4
+
+Rails:
+  Enabled: false
+
+Style/AccessorMethodName:
+  Enabled: false
+
+Style/TrivialAccessors:
+  Enabled: false
+
+Style/Documentation:
+  Exclude:
+    - 'spec/**/*.rb'
+    - 'tests/**/*.rb'
+
+Style/StringLiterals: 
+  Enabled: false
+
+Style/RegexpLiteral:
+  Enabled: false
+
+Style/SpaceInsideStringInterpolation:
+  EnforcedStyle: no_space
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/BlockDelimiters:
+  Exclude:
+    - 'spec/**/*.rb'
+
+Lint/AmbiguousRegexpLiteral:
+  Enabled: false
+
+
+Metrics/MethodLength:
+  Exclude:
+    - 'spec/**/*.rb'
+
+Metrics/AbcSize:
+  Max: 20
+
+Metrics/LineLength:
+  Max: 100
+  Exclude:
+    - 'spec/**/*.rb'
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*.rb'
+
+Rails/Date:
+  Enabled: false
+
+Rails/TimeZone:
+  Enabled: false

data/.travis.yml

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 palkan
+
+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,204 @@
+# N + 1 Control
+
+RSpec and Minitest matchers to prevent the N+1 queries problem.
+
+### Why yet another gem to assert DB queries?
+
+Unlike other libraries (such as [db-query-matchers](https://github.com/brigade/db-query-matchers), [rspec-sqlimit](https://github.com/nepalez/rspec-sqlimit), etc), with `n_plus_one_control` you don't have to specify exact expectations to control your code behaviour (e.g. `expect { subject }.to query(2).times`).
+
+Such expectations are rather hard to maintain, 'cause there is a big chance of adding more queries, not related to the system under test.
+
+NPlusOneControl works differently. It evaluates the code under consideration several times with different scale factors to make sure that the number of DB queries behaves as expected (i.e. O(1) instead of O(N)).
+
+### Why not just use [`bullet`](https://github.com/flyerhzm/bullet)?
+
+Of course, it's possible to use Bullet in tests (see more [here](https://evilmartians.com/chronicles/fighting-the-hydra-of-n-plus-one-queries)), but it's not a _silver bullet_: there can be both false positives and true negatives.
+
+This gem was born after I've found myself not able to verify with a test yet another N+1 problem.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+group :test do
+  gem 'n_plus_one_control'
+end
+```
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+### RSpec
+
+First, add NPlusOneControl to your `spec_helper.rb`:
+
+```ruby
+# spec_helper.rb
+...
+
+require "n_plus_one_control/rspec"
+```
+
+Then:
+
+```ruby
+# Wrap example into a context with :n_plus_one tag
+context "N+1", :n_plus_one do
+  # Define `populate` callbacks which is responsible for data
+  # generation (and whatever else).
+  #
+  # It accepts one argument – the scale factor (read below)
+  populate { |n| create_list(:post, n) }
+
+  specify do
+    expect { get :index }.to perform_constant_number_of_queries
+  end
+end
+```
+
+**NOTE:** do not use memoized values within the expectation block!
+
+```ruby
+# BAD – won't work!
+
+subject { get :index }
+
+specify do
+  expect { subject }.to perform_constant_number_of_queries
+end
+```
+
+Availables modifiers:
+
+```ruby
+# You can specify the RegExp to filter queries.
+# By default, it only considers SELECT queries.
+expect { ... }.to perform_constant_number_of_queries.matching(/INSERT/)
+
+# You can also provide custom scale factors
+expect { ... }.to perform_constant_number_of_queries.with_scale_factors(10, 100)
+```
+
+### Minitest
+
+First, add NPlusOneControl to your `test_helper.rb`:
+
+```ruby
+# test_helper.rb
+...
+
+require "n_plus_one_control/minitest"
+```
+
+Then use `assert_perform_constant_number_of_queries` assertion method:
+
+```ruby
+def test_no_n_plus_one_error
+  populate = ->(n) { create_list(:post, n) }
+
+  assert_perform_constant_number_of_queries(populate: populate) do
+    get :index
+  end
+end
+```
+
+You can also specify custom scale factors or filter patterns:
+
+```ruby
+assert_perform_constant_number_of_queries(
+  populate: populate,
+  scale_factors: [2, 5, 10]
+) do
+  get :index
+end
+
+assert_perform_constant_number_of_queries(
+  populate: populate,
+  matching: /INSERT/
+) do
+  do_some_havey_stuff
+end
+```
+
+You can also specify `populate` as a test class instance method:
+
+```ruby
+def populate(n)
+  create_list(:post, n)
+end
+
+def test_no_n_plus_one_error
+  assert_perform_constant_number_of_queries do
+    get :index
+  end
+end
+```
+
+### Configuration
+
+There are some global configuration parameters (and their corresponding defaults):
+
+```ruby
+# Default scale factors to use.
+# We use the smallest possible but representative scale factors by default.
+self.default_scale_factors = [2, 3]
+
+# Print performed queries if true in the case of failure
+self.verbose = false
+
+# Ignore matching queries
+self.ignore = /^(BEGIN|COMMIT|SAVEPOINT|RELEASE)/
+
+# ActiveSupport notifications event to track queries.
+# We track ActiveRecord event by default,
+# but can also track rom-rb events ('sql.rom') as well.
+self.event = 'sql.active_record'
+```
+
+## How does it work?
+
+Take a look at our [Executor](https://github.com/palkan/test-prof/tree/master/lib/n_plus_one_control/executor.rb) to figure out what's under the hood.
+
+## What's next?
+
+It may be useful to provide more matchers/assertions, for example:
+
+```ruby
+
+# Actually, that means that it is N+1))
+assert_linear_number_of_queries { ... } 
+
+# But we can tune it with `coef` and handle such cases as selecting in batches
+assert_linear_number_of_queries(coef: 0.1) do
+  Post.find_in_batches { ... }
+end
+
+# probably, also make sense to add another curve types
+assert_logarithmic_number_of_queries { ... }
+```
+
+If you want to discuss or implement any of these, feel free to open an [issue]() or propose a [pull request]().
+
+## Development
+
+```sh
+# install deps
+bundle install
+
+# run tests
+bundle exec rake
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/palkan/n_plus_one_control.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['tests/**/*_test.rb']
+end
+
+RuboCop::RakeTask.new
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => [:spec, :test, :rubocop]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "n_plus_one_control"
+
+# 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

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/lib/n_plus_one_control.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "n_plus_one_control/version"
+require "n_plus_one_control/executor"
+
+# RSpec and Minitest matchers to prevent N+1 queries problem.
+module NPlusOneControl
+  class << self
+    attr_accessor :default_scale_factors, :verbose, :ignore, :event
+
+    def failure_message(queries)
+      msg = ["Expected to make the same number of queries, but got:\n"]
+      queries.each do |(scale, data)|
+        msg << "  #{data.size} for N=#{scale}\n"
+        msg << data.map { |sql| "    #{sql}\n" }.join.to_s if verbose
+      end
+      msg.join
+    end
+  end
+
+  # Scale factors to use.
+  # Use the smallest possible but representative scale factors by default.
+  self.default_scale_factors = [2, 3]
+
+  # Print performed queries if true
+  self.verbose = false
+
+  # Ignore matching queries
+  self.ignore = /^(BEGIN|COMMIT|SAVEPOINT|RELEASE)/
+
+  # ActiveSupport notifications event to track queries.
+  # We track ActiveRecord event by default,
+  # but can also track rom-rb events ('sql.rom') as well.
+  self.event = 'sql.active_record'
+end

data/lib/n_plus_one_control/executor.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module NPlusOneControl
+  # Runs code for every scale factor
+  # and returns collected queries.
+  module Executor
+    # Subscribes to ActiveSupport notifications and collect matching queries.
+    class Collector
+      def initialize(pattern)
+        @pattern = pattern
+      end
+
+      def call
+        @queries = []
+        ActiveSupport::Notifications
+          .subscribed(method(:callback), NPlusOneControl.event) do
+          yield
+        end
+        @queries
+      end
+
+      def callback(_name, _start, _finish, _message_id, values)
+        return if %w[CACHE SCHEMA].include? values[:name]
+        @queries << values[:sql] if @pattern.nil? || (values[:sql] =~ @pattern)
+      end
+    end
+
+    class << self
+      def call(population:, scale_factors: nil, matching: nil)
+        raise ArgumentError, "Block is required!" unless block_given?
+
+        results = []
+        collector = Collector.new(matching)
+
+        (scale_factors || NPlusOneControl.default_scale_factors).each do |scale|
+          with_transaction do
+            population.call(scale)
+            results << [scale, collector.call { yield }]
+          end
+        end
+        results
+      end
+
+      private
+
+      def with_transaction
+        return yield unless defined?(ActiveRecord)
+        ActiveRecord::Base.connection.begin_transaction(joinable: false)
+        yield
+      ensure
+        ActiveRecord::Base.connection.rollback_transaction
+      end
+    end
+  end
+end

data/lib/n_plus_one_control/minitest.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "n_plus_one_control"
+
+module NPlusOneControl
+  # Minitest assertions
+  module MinitestHelper
+    def assert_perform_constant_number_of_queries(
+      populate: nil,
+      matching: nil,
+      scale_factors: nil
+    )
+
+      raise ArgumentError, "Block is required" unless block_given?
+
+      queries = NPlusOneControl::Executor.call(
+        population: populate || method(:populate),
+        matching: matching || /^SELECT/i,
+        scale_factors: scale_factors || NPlusOneControl.default_scale_factors
+      ) { yield }
+
+      counts = queries.map(&:last).map(&:size)
+
+      assert counts.max == counts.min, NPlusOneControl.failure_message(queries)
+    end
+  end
+end
+
+Minitest::Test.include NPlusOneControl::MinitestHelper

data/lib/n_plus_one_control/rspec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "n_plus_one_control"
+require "n_plus_one_control/rspec/dsl"
+require "n_plus_one_control/rspec/matcher"
+require "n_plus_one_control/rspec/context"
+
+module NPlusOneControl
+  module RSpec # :nodoc:
+  end
+end
+
+::RSpec.configure do |config|
+  config.extend NPlusOneControl::RSpec::DSL, n_plus_one: true
+end

data/lib/n_plus_one_control/rspec/context.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+::RSpec.shared_context "n_plus_one_control", n_plus_one: true do
+  # Helper to access populate block from within example/matcher
+  let(:n_plus_one_populate) do |ex|
+    if ex.example_group.populate.nil?
+      raise(
+        <<~MSG
+          Populate block is missing!
+
+          Please provide populate callback, e.g.:
+
+            populate { |n| n.times { create_some_stuff } }
+        MSG
+      )
+    end
+    ->(n) { ex.instance_exec(n, &ex.example_group.populate) }
+  end
+end

data/lib/n_plus_one_control/rspec/dsl.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module NPlusOneControl
+  module RSpec
+    # Extends RSpec ExampleGroup with populate method
+    module DSL
+      # Setup populate callback, which is used
+      # to prepare data for each run.
+      def populate
+        return @populate unless block_given?
+
+        @populate = Proc.new
+      end
+    end
+  end
+end

data/lib/n_plus_one_control/rspec/matcher.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# rubocop:disable  Metrics/BlockLength
+::RSpec::Matchers.define :perform_constant_number_of_queries do
+  supports_block_expectations
+
+  chain :with_scale_factors do |*factors|
+    @factors = factors
+  end
+
+  chain :matching do |pattern|
+    @pattern = pattern
+  end
+
+  match do |actual, *_args|
+    raise ArgumentError, "Block is required" unless actual.is_a? Proc
+
+    raise "Missing tag :n_plus_one" unless
+      @matcher_execution_context.respond_to?(:n_plus_one_populate)
+
+    populate = @matcher_execution_context.n_plus_one_populate
+
+    # by default we're looking for select queries
+    pattern = @pattern || /^SELECT/i
+
+    @queries = NPlusOneControl::Executor.call(
+      population: populate,
+      matching: pattern,
+      scale_factors: @factors,
+      &actual
+    )
+
+    counts = @queries.map(&:last).map(&:size)
+
+    counts.max == counts.min
+  end
+
+  match_when_negated do |_actual|
+    raise "This matcher doesn't support negation"
+  end
+
+  failure_message { |_actual| NPlusOneControl.failure_message(@queries) }
+end

data/lib/n_plus_one_control/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module NPlusOneControl
+  VERSION = "0.0.3"
+end

data/n_plus_one_control.gemspec

@@ -0,0 +1,46 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'n_plus_one_control/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "n_plus_one_control"
+  spec.version       = NPlusOneControl::VERSION
+  spec.authors       = ["palkan"]
+  spec.email         = ["dementiev.vm@gmail.com"]
+
+  spec.summary       = "RSpec and Minitest matchers to prevent N+1 queries problem"
+  spec.description   = %{
+    RSpec and Minitest matchers to prevent N+1 queries problem.
+
+    Evaluates code under consideration several times with different scale factors
+    to make sure that the number of DB queries behaves as expected (i.e. O(1) instead of O(N)).
+
+    Example:
+
+      ```ruby
+      context "N+1", :n_plus_one do
+        populate { |n| create_list(:post, n) }
+
+        specify do
+          expect { get :index }.to perform_constant_number_of_queries
+        end
+      end
+      ```
+  }
+  spec.homepage      = "http://github.com/palkan/n_plus_one_control"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.5"
+  spec.add_development_dependency "minitest", "~> 5.9"
+  spec.add_development_dependency "factory_girl", "~> 4.8.0"
+  spec.add_development_dependency "rubocop", "~> 0.49"
+  spec.add_development_dependency "activerecord", "~> 5.1"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "pry-byebug"
+end

data/spec/n_plus_one_control/executor_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe NPlusOneControl::Executor do
+  let(:populate) do
+    ->(n) { create_list(:post, n) }
+  end
+
+  let(:observable) do
+    -> { Post.find_each(&:user) }
+  end
+
+  it "raises when block is missing" do
+    expect { described_class.call(population: populate) }
+      .to raise_error(ArgumentError, "Block is required!")
+  end
+
+  it "raises when populate is missing" do
+    expect { described_class.call(&observable) }
+      .to raise_error(ArgumentError, /population/)
+  end
+
+  it "returns correct counts for default scales" do
+    result = described_class.call(
+      population: populate,
+      &observable
+    )
+
+    expect(result.size).to eq 2
+    expect(result.first[0]).to eq 2
+    expect(result.first[1].size).to eq 3
+    expect(result.last[0]).to eq 3
+    expect(result.last[1].size).to eq 4
+  end
+
+  it "returns correct counts for custom scales" do
+    result = described_class.call(
+      population: populate,
+      scale_factors: [5, 10, 100],
+      &observable
+    )
+
+    expect(result.size).to eq 3
+    expect(result.first[0]).to eq 5
+    expect(result.first[1].size).to eq 6
+    expect(result.second[0]).to eq 10
+    expect(result.second[1].size).to eq 11
+    expect(result.last[0]).to eq 100
+    expect(result.last[1].size).to eq 101
+  end
+
+  it "returns correct counts with custom match" do
+    result = described_class.call(
+      population: populate,
+      matching: /users/,
+      &observable
+    )
+
+    expect(result.first[0]).to eq 2
+    expect(result.first[1].size).to eq 2
+    expect(result.last[0]).to eq 3
+    expect(result.last[1].size).to eq 3
+  end
+end

data/spec/n_plus_one_control/rspec_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe NPlusOneControl::RSpec do
+  context "when no N+1", :n_plus_one do
+    populate { |n| create_list(:post, n) }
+
+    specify do
+      expect { Post.preload(:user).find_each { |p| p.user.name } }
+        .to perform_constant_number_of_queries
+    end
+  end
+
+  context "when has N+1", :n_plus_one do
+    populate { |n| create_list(:post, n) }
+
+    specify do
+      expect do
+        expect { Post.find_each { |p| p.user.name } }
+          .to perform_constant_number_of_queries
+      end.to raise_error(RSpec::Expectations::ExpectationNotMetError)
+    end
+  end
+
+  context "when context is missing" do
+    specify do
+      expect do
+        expect { subject }.to perform_constant_number_of_queries
+      end.to raise_error(/missing tag/i)
+    end
+  end
+
+  context "when populate is missing", :n_plus_one do
+    specify do
+      expect do
+        expect { subject }.to perform_constant_number_of_queries
+      end.to raise_error(/please provide populate/i)
+    end
+  end
+
+  context "when negated" do
+    specify do
+      expect do
+        expect { subject }.not_to perform_constant_number_of_queries
+      end.to raise_error(/support negation/i)
+    end
+  end
+
+  context "when verbose", :n_plus_one do
+    populate { |n| create_list(:post, n) }
+
+    around(:each) do |ex|
+      NPlusOneControl.verbose = true
+      ex.run
+      NPlusOneControl.verbose = false
+    end
+
+    specify do
+      expect do
+        expect { Post.find_each { |p| p.user.name } }
+          .to perform_constant_number_of_queries
+      end.to raise_error(RSpec::Expectations::ExpectationNotMetError, /select .+ from/i)
+    end
+  end
+
+  context "with scale_factors", :n_plus_one do
+    populate { |n| create_list(:post, n) }
+
+    specify do
+      expect { Post.find_each { |p| p.user.name } }
+        .to perform_constant_number_of_queries.with_scale_factors(1, 1)
+    end
+  end
+
+  context "with matching", :n_plus_one do
+    populate { |n| create_list(:post, n) }
+
+    specify do
+      expect { Post.find_each { |p| p.user.name } }
+        .to perform_constant_number_of_queries.matching(/posts/)
+    end
+  end
+end

data/spec/n_plus_one_control_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe NPlusOneControl do
+  it "has a version number" do
+    expect(NPlusOneControl::VERSION).not_to be nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require "n_plus_one_control/rspec"
+require "benchmark"
+require "active_record"
+require "factory_girl"
+require "pry-byebug"
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+
+  config.order = :random
+  config.filter_run focus: true
+  config.run_all_when_everything_filtered = true
+
+  config.include FactoryGirl::Syntax::Methods
+
+  config.before(:each) do
+    ActiveRecord::Base.connection.begin_transaction(joinable: false)
+  end
+
+  config.after(:each) do
+    ActiveRecord::Base.connection.rollback_transaction
+  end
+end

data/spec/support/post.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+ActiveRecord::Schema.define do
+  create_table :posts do |t|
+    t.string :title
+    t.integer :user_id
+  end
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :user
+end
+
+FactoryGirl.define do
+  factory :post do
+    title "Title"
+    user
+  end
+end

data/spec/support/user.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+ActiveRecord::Schema.define do
+  create_table :users do |t|
+    t.string :name
+  end
+end
+
+class User < ActiveRecord::Base
+  has_many :posts
+end
+
+FactoryGirl.define do
+  factory :user do
+    name "John"
+  end
+end

data/tests/minitest_test.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "test_helper"
+
+class TestMinitest < Minitest::Test
+  def test_no_n_plus_one_error
+    populate = ->(n) { create_list(:post, n) }
+
+    assert_perform_constant_number_of_queries(populate: populate) do
+      Post.preload(:user).find_each { |p| p.user.name }
+    end
+  end
+
+  def test_with_n_plus_one_error
+    populate = ->(n) { create_list(:post, n) }
+
+    e = assert_raises Minitest::Assertion do
+      assert_perform_constant_number_of_queries(populate: populate) do
+        Post.find_each { |p| p.user.name }
+      end
+    end
+
+    assert_match "Expected to make the same number of queries", e.message
+    assert_match "3 for N=2", e.message
+    assert_match "4 for N=3", e.message
+  end
+
+  def test_no_n_plus_one_error_with_scale_factors
+    populate = ->(n) { create_list(:post, n) }
+
+    assert_perform_constant_number_of_queries(
+      populate: populate,
+      scale_factors: [1, 1]
+    ) do
+      Post.find_each { |p| p.user.name }
+    end
+  end
+
+  def test_no_n_plus_one_error_with_matching
+    populate = ->(n) { create_list(:post, n) }
+
+    assert_perform_constant_number_of_queries(
+      populate: populate,
+      matching: /posts/
+    ) do
+      Post.find_each { |p| p.user.name }
+    end
+  end
+
+  def populate(n)
+    create_list(:post, n)
+  end
+
+  def test_fallback_to_populate_method
+    e = assert_raises Minitest::Assertion do
+      assert_perform_constant_number_of_queries do
+        Post.find_each { |p| p.user.name }
+      end
+    end
+
+    assert_match "Expected to make the same number of queries", e.message
+  end
+end

data/tests/test_helper.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "minitest/pride"
+
+$LOAD_PATH << File.expand_path("../../lib", __FILE__)
+Thread.abort_on_exception = true
+
+require "n_plus_one_control/minitest"
+require "benchmark"
+require "active_record"
+require "factory_girl"
+require "pry-byebug"
+
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+
+Dir["#{File.dirname(__FILE__)}/../spec/support/**/*.rb"].each { |f| require f }
+
+module TransactionalTests
+  def setup
+    ActiveRecord::Base.connection.begin_transaction(joinable: false)
+    super
+  end
+
+  def teardown
+    super
+    ActiveRecord::Base.connection.rollback_transaction
+  end
+end
+
+Minitest::Test.prepend TransactionalTests
+Minitest::Test.include FactoryGirl::Syntax::Methods

metadata

@@ -0,0 +1,203 @@
+--- !ruby/object:Gem::Specification
+name: n_plus_one_control
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- palkan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-06-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !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.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.8.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.49'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.49'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "\n    RSpec and Minitest matchers to prevent N+1 queries problem.\n\n
+  \   Evaluates code under consideration several times with different scale factors\n
+  \   to make sure that the number of DB queries behaves as expected (i.e. O(1) instead
+  of O(N)).\n\n    Example:\n\n      ```ruby\n      context \"N+1\", :n_plus_one do\n
+  \       populate { |n| create_list(:post, n) }\n\n        specify do\n          expect
+  { get :index }.to perform_constant_number_of_queries\n        end\n      end\n      ```\n
+  \ "
+email:
+- dementiev.vm@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/n_plus_one_control.rb
+- lib/n_plus_one_control/executor.rb
+- lib/n_plus_one_control/minitest.rb
+- lib/n_plus_one_control/rspec.rb
+- lib/n_plus_one_control/rspec/context.rb
+- lib/n_plus_one_control/rspec/dsl.rb
+- lib/n_plus_one_control/rspec/matcher.rb
+- lib/n_plus_one_control/version.rb
+- n_plus_one_control.gemspec
+- spec/n_plus_one_control/executor_spec.rb
+- spec/n_plus_one_control/rspec_spec.rb
+- spec/n_plus_one_control_spec.rb
+- spec/spec_helper.rb
+- spec/support/post.rb
+- spec/support/user.rb
+- tests/minitest_test.rb
+- tests/test_helper.rb
+homepage: http://github.com/palkan/n_plus_one_control
+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.6.4
+signing_key: 
+specification_version: 4
+summary: RSpec and Minitest matchers to prevent N+1 queries problem
+test_files: []