rspec-benchmark 0.3.0 → 0.4.0

data/lib/rspec/benchmark/iteration_matcher.rb

@@ -1,4 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
+require 'benchmark-perf'
 
 module RSpec
   module Benchmark
@@ -9,9 +11,9 @@ module RSpec
       class Matcher
         def initialize(iterations, **options)
           @iterations = iterations
-          time   = options.fetch(:time) { 0.2 }
-          warmup = options.fetch(:warmup) { 0.1 }
-          @bench = ::Benchmark::Perf::Iteration.new(time: time, warmup: warmup)
+          @time       = options.fetch(:time) { 0.2 }
+          @warmup     = options.fetch(:warmup) { 0.1 }
+          @bench      = ::Benchmark::Perf::Iteration
         end
 
         # Indicates this matcher matches against a block
@@ -27,10 +29,34 @@ module RSpec
         #
         # @api private
         def matches?(block)
-          @average, @stddev, = @bench.run(&block)
+          @average, @stddev, = @bench.run(time: @time, warmup: @warmup, &block)
           @iterations <= (@average + 3 * @stddev)
         end
 
+        # The time before measurements are taken
+        #
+        # @param [Numeric] value
+        #   the time before measurements are taken
+        #
+        # @api public
+        def warmup(value)
+          @warmup = value
+          self
+        end
+
+        # Time to measure iteration for
+        #
+        # @param [Numeric] value
+        #   the time to take measurements for
+        #
+        # @api public
+        def within(value)
+          @time = value
+          self
+        end
+
+        # Sugar syntax for iterations per second
+        # @api public
         def ips
           self
         end

data/lib/rspec/benchmark/matchers.rb

@@ -1,8 +1,9 @@
-# encoding: utf-8
+# frozen_string_literal
 
-require 'rspec/benchmark/timing_matcher'
-require 'rspec/benchmark/iteration_matcher'
-require 'rspec/benchmark/comparison_matcher'
+require_relative 'comparison_matcher'
+require_relative 'complexity_matcher'
+require_relative 'iteration_matcher'
+require_relative 'timing_matcher'
 
 module RSpec
   module Benchmark
@@ -75,6 +76,84 @@ module RSpec
       def perform_slower_than(**options, &sample)
         ComparisonMatcher::Matcher.new(sample, :slower, options)
       end
+
+      # Pass if code block performs constant
+      #
+      # @example
+      #   expect { ... }.to perform_constant
+      #   expect { ... }.to perform_constant.within(1, 100_000)
+      #   expect { ... }.to perform_constant.within(1, 100_000, ratio: 4)
+      #
+      # @api public
+      def perform_constant(**options)
+        ComplexityMatcher::Matcher.new(:constant, options)
+      end
+
+      # Pass if code block performs logarithmic
+      #
+      # @example
+      #   expect { ... }.to perform_logarithmic
+      #   expect { ... }.to perform_logarithmic
+      #   expect { ... }.to perform_logarithmic.within(1, 100_000)
+      #   expect { ... }.to perform_logarithimic.within(1, 100_000, ratio: 4)
+      #
+      # @api public
+      def perform_logarithmic(**options)
+        ComplexityMatcher::Matcher.new(:logarithmic, options)
+      end
+
+      # Pass if code block performs linear
+      #
+      # @example
+      #   expect { ... }.to perform_linear
+      #   expect { ... }.to perform_linear.within(1, 100_000)
+      #   expect { ... }.to perform_linear.within(1, 100_000, ratio: 4)
+      #
+      # @api public
+      def perform_linear(**options)
+        ComplexityMatcher::Matcher.new(:linear, options)
+      end
+
+      # Pass if code block performs power
+      #
+      # @example
+      #   expect { ... }.to perform_power
+      #   expect { ... }.to perform_power.within(1, 100_000)
+      #   expect { ... }.to perform_power.within(1, 100_000, ratio: 4)
+      #
+      # @api public
+      def perform_power(**options)
+        ComplexityMatcher::Matcher.new(:power, options)
+      end
+
+      # Pass if code block performs exponential
+      #
+      # @example
+      #   expect { ... }.to perform_exponential
+      #   expect { ... }.to perform_exponential.within(1, 100_000)
+      #   expect { ... }.to perform_exponential.within(1, 100_000, ratio: 4)
+      #
+      # @api public
+      def perform_exponential(**options)
+        ComplexityMatcher::Matcher.new(:exponential, options)
+      end
+
+      # Generate a geometric progression of inputs
+      #
+      # The default range is generated in the multiples of 8.
+      #
+      # @example
+      #   bench_range(8, 8 << 10)
+      #   # => [8, 64, 512, 4096, 8192]
+      #
+      # @param [Integer] start
+      # @param [Integer] limit
+      # @param [Integer] ratio
+      #
+      # @api public
+      def bench_range(*args)
+        ::Benchmark::Trend.range(*args)
+      end
     end # Matchers
   end # Benchmark
 end # RSpec

data/lib/rspec/benchmark/timing_matcher.rb

@@ -1,4 +1,8 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
+require 'benchmark-perf'
+
+require_relative 'format_time'
 
 module RSpec
   module Benchmark
@@ -13,12 +17,11 @@ module RSpec
 
         def initialize(threshold, **options)
           @threshold = threshold
-          @samples = options.fetch(:samples) { 30 }
-          @scale = threshold.to_s.split(/\./).last.size
-          @block = nil
-          @confidence_interval = nil
-          warmup = options.fetch(:warmup) { 1 }
-          @bench = ::Benchmark::Perf::ExecutionTime.new(warmup: warmup)
+          @samples   = options.fetch(:samples) { 1 }
+          @warmup    = options.fetch(:warmup) { 1 }
+          @scale     = threshold.to_s.split(/\./).last.size
+          @block     = nil
+          @bench     = ::Benchmark::Perf::ExecutionTime
         end
 
         # Indicates this matcher matches against a block
@@ -36,7 +39,7 @@ module RSpec
         def matches?(block)
           @block = block
           return false unless block.is_a?(Proc)
-          @average, @stddev = @bench.run(@samples, &block)
+          @average, @stddev = @bench.run(repeat: @samples, warmup: @warmup, &block)
           @average <= @threshold
         end
 
@@ -44,11 +47,34 @@ module RSpec
           !matches?(block) && block.is_a?(Proc)
         end
 
-        def and_sample(samples)
+        # The time before measurements are taken
+        #
+        # @param [Numeric] value
+        #   the time before measurements are taken
+        #
+        # @api public
+        def warmup(value)
+          @warmup = value
+          self
+        end
+
+        # How many times to repeat measurement
+        #
+        # @param [Integer] samples
+        #   the number of times to repeat the measurement
+        #
+        # @api public
+        def sample(samples)
           @samples = samples
           self
         end
 
+        # No-op, syntactic sugar.
+        # @api public
+        def times
+          self
+        end
+
         def secs
           self
         end

data/lib/rspec/benchmark/version.rb

@@ -1,7 +1,7 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 module RSpec
   module Benchmark
-    VERSION = "0.3.0"
+    VERSION = "0.4.0"
   end # Benchmark
 end # RSpec

data/rspec-benchmark.gemspec

@@ -1,4 +1,3 @@
-# coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'rspec/benchmark/version'
@@ -9,18 +8,23 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Piotr Murach"]
   spec.email         = [""]
   spec.summary       = %q{Performance testing matchers for RSpec}
-  spec.description   = %q{Performance testing matchers for RSpec that provide simple way to specify speed benchmark expectations}
+  spec.description   = %q{Performance testing matchers for RSpec that provide simple way to specify speed and algorithmic complexity benchmark expectations}
   spec.homepage      = ""
   spec.license       = "MIT"
 
-  spec.files         = `git ls-files -z`.split("\x0")
+  spec.files         = Dir['{lib,spec}/**/*.rb']
+  spec.files        += Dir['tasks/*', 'rspec-benchmark.gemspec']
+  spec.files        += Dir['README.md', 'CHANGELOG.md', 'LICENSE.txt', 'Rakefile']
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^spec/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency 'benchmark-perf', '~> 0.2.0'
+  spec.required_ruby_version = '>= 2.0.0'
+
+  spec.add_dependency 'benchmark-perf', '~> 0.4.0'
+  spec.add_dependency 'benchmark-trend', '~> 0.2.0'
   spec.add_dependency 'rspec', '>= 3.0.0', '< 4.0.0'
 
-  spec.add_development_dependency 'bundler', '>= 1.5.0', '< 2.0'
-  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'rake', '~> 10.0'
 end

data/spec/spec_helper.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
-if RUBY_VERSION > '1.9' and (ENV['COVERAGE'] || ENV['TRAVIS'])
+if ENV['COVERAGE'] || ENV['TRAVIS']
   require 'simplecov'
   require 'coveralls'
 
@@ -15,22 +15,16 @@ if RUBY_VERSION > '1.9' and (ENV['COVERAGE'] || ENV['TRAVIS'])
   end
 end
 
-require 'rspec-benchmark'
+require 'bundler/setup'
+require 'rspec/benchmark'
 
 RSpec.configure do |config|
   config.include(RSpec::Benchmark::Matchers)
 
-  config.expect_with :rspec do |expectations|
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
   end
 
-  config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = true
-  end
-
-  config.filter_run :focus
-  config.run_all_when_everything_filtered = true
-
   config.disable_monkey_patching!
 
   config.warnings = true
@@ -40,8 +34,4 @@ RSpec.configure do |config|
   end
 
   config.profile_examples = 2
-
-  config.order = :random
-
-  Kernel.srand config.seed
 end

data/spec/unit/comparison_matcher_spec.rb

@@ -16,13 +16,34 @@ RSpec.describe RSpec::Benchmark::ComparisonMatcher::Matcher do
   end
 
   it "allows to configure matcher timings" do
-    bench = double(run: 100)
-    allow(::Benchmark::Perf::Iteration).to receive(:new).and_return(bench)
-    sample = -> { 'x' * 10 * 1024 }
-    expect { 1 << 1 }.to perform_faster_than(warmup: 0.2, time: 0.3, &sample).exactly(1).times
+    allow(::Benchmark::Perf::Iteration).to receive(:run).and_return(100)
 
-    expect(::Benchmark::Perf::Iteration).to have_received(:new).
-      with(time: 0.3, warmup: 0.2)
+    expect {
+      1 << 1
+    }.to perform_faster_than.within(0.3).warmup(0.2) {
+      'x' * 10 * 1024
+    }.once
+
+    expect(::Benchmark::Perf::Iteration).to have_received(:run).with(time: 0.3, warmup: 0.2).twice
+  end
+
+  context 'algorithms comparison' do
+    def clamp(num, min, max)
+      [num, min, max].sort[1]
+    end
+
+    def clamp_fast(num, min, max)
+      num > max ? max : (num < min ? min : num)
+    end
+
+    it "infers one implementation faster than another" do
+      num = rand(1_000)
+      expect {
+        clamp_fast(num, num / 2, num * 2)
+      }.to perform_faster_than {
+        clamp(num, num / 2, num * 2)
+      }.at_least(1.5).times
+    end
   end
 
   describe "expect { ... }.to perform_faster_than(...)" do

data/spec/unit/composable_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RSpec.describe 'composable specs' do
+  it "composes perform_under and perform_at_least matchers" do
+    expect { 
+      'x' * 1024 * 10
+    }.to perform_under(6).ms and perform_at_least(10_000).ips
+  end
+end

data/spec/unit/perform_at_least_spec.rb

@@ -1,15 +1,15 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 RSpec.describe '#perform_at_least' do
-
   it "allows to configure matcher timings" do
-    bench = double(run: [10_000, 100])
-    allow(::Benchmark::Perf::Iteration).to receive(:new).and_return(bench)
+    bench = [10_000, 100]
+    allow(::Benchmark::Perf::Iteration).to receive(:run).and_return(bench)
+
     expect {
       'x' * 1024 * 10
-    }.to perform_at_least(10_000, warmup: 0.2, time: 0.3)
+    }.to perform_at_least(10_000).within(0.3).warmup(0.2)
 
-    expect(::Benchmark::Perf::Iteration).to have_received(:new).
+    expect(::Benchmark::Perf::Iteration).to have_received(:run).
       with(time: 0.3, warmup: 0.2)
   end
 

data/spec/unit/perform_constant_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+RSpec.describe 'RSpec::Benchmark::ComplexityMatcher', '#perform_constant' do
+  # exponential
+  def fibonacci(n)
+    n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2)
+  end
+
+  it "propagates error inside expectation" do
+    expect {
+      expect { raise 'boom' }.to perform_constant
+    }.to raise_error(StandardError, /boom/)
+  end
+
+  context "expect { ... }.to perfom_constant" do
+    it "passes if the block performs constant" do
+      expect { |n, i|
+        n * i
+      }.to perform_constant.in_range(1, 1000).sample(100)
+    end
+
+    it "fails if the block doesn't perform constant" do
+      expect {
+        expect { |n, i|
+          fibonacci(n)
+        }.to perform_constant.in_range(1, 15).ratio(2).sample(100)
+      }.to raise_error("expected block to perform constant, but performed exponential")
+    end
+  end
+
+  context "expect { ... }.not_to perfom_constant" do
+    it "passes if the block does not perform constant" do
+      expect { |n, i|
+        fibonacci(n)
+      }.not_to perform_constant.in_range(1, 15).ratio(2).sample(100)
+    end
+
+    it "fails if the block doesn't perform constant" do
+      expect {
+        expect { |n, i|
+          n * i
+        }.not_to perform_constant.in_range(1, 1000).sample(100)
+      }.to raise_error("expected block not to perform constant, but performed constant")
+    end
+  end
+end

data/spec/unit/perform_exponential_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+RSpec.describe 'RSpec::Benchmark::ComplexityMatcher', '#perform_exponential' do
+  # exponential
+  def fibonacci(n)
+    n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2)
+  end
+
+  it "propagates error inside expectation" do
+    expect {
+      expect { raise 'boom' }.to perform_exponential
+    }.to raise_error(StandardError, /boom/)
+  end
+
+  context "expect { ... }.to perfom_exponential" do
+    it "passes if the block performs exponential" do
+      expect { |n, i|
+        fibonacci(n)
+      }.to perform_exponential.in_range(1, 15).ratio(2).sample(100)
+    end
+
+    it "fails if the block doesn't perform exponential" do
+      expect {
+        expect { |n| n }.to perform_exponential.in_range(1, 10_000).sample(100)
+      }.to raise_error("expected block to perform exponential, but performed constant")
+    end
+  end
+
+  context "expect { ... }.not_to perfom_exponential" do
+    it "passes if the block does not perform exponential" do
+      expect { |n| n }.not_to perform_exponential.in_range(1, 10_000).sample(100)
+    end
+
+    it "fails if the block doesn't perform exponential" do
+      expect {
+        expect { |n|
+          fibonacci(n)
+        }.not_to perform_exponential.in_range(1, 15).ratio(2).sample(100)
+      }.to raise_error("expected block not to perform exponential, but performed exponential")
+    end
+  end
+end