napa 0.3.0 → 0.4.0

data/napa.gemspec

@@ -14,6 +14,7 @@ Gem::Specification.new do |gem|
   gem.name          = "napa"
   gem.require_paths = ["lib"]
   gem.version       = Napa::VERSION
+  gem.required_ruby_version = '>= 2.0'
 
 
   gem.add_dependency 'rake'
@@ -27,10 +28,10 @@ Gem::Specification.new do |gem|
   gem.add_dependency 'roar'
   gem.add_dependency 'statsd-ruby'
   gem.add_dependency 'racksh'
+  gem.add_dependency 'git'
 
   gem.add_development_dependency 'rspec'
   gem.add_development_dependency 'pry'
-  gem.add_development_dependency 'git'
   gem.add_development_dependency 'rubocop'
   gem.add_development_dependency 'activerecord', '~>3.2.2'
   gem.add_development_dependency 'sqlite3'

data/spec/active_record_extensions/filter_by_hash_spec.rb

@@ -2,11 +2,13 @@ require 'active_record'
 require 'spec_helper'
 require 'napa/active_record_extensions/filter_by_hash'
 
-class Foo < ActiveRecord::Base
-  include Napa::FilterByHash
-end
 
 describe Napa::FilterByHash do
+  before do
+    expect(ActiveSupport::Deprecation).to receive(:warn)
+    class Foo < ActiveRecord::Base; include Napa::FilterByHash; end
+  end
+
   context 'when a hash is provided' do
     it 'returns an AR relation' do
       expect(Foo.filter).to be_a(ActiveRecord::Relation)

data/spec/active_record_extensions/seeder_spec.rb

@@ -0,0 +1,13 @@
+require 'active_record'
+require 'spec_helper'
+require 'napa/active_record_extensions/seeder'
+
+describe Napa::ActiveRecordSeeder do
+
+  context 'when a valid file is not provided' do
+    it 'raises an exception' do
+    	expect{Napa::ActiveRecordSeeder.load_file 'not-a-file'}.to raise_error
+    end
+  end
+
+end

data/spec/authentication_spec.rb

@@ -5,8 +5,8 @@ describe Napa::Authentication do
   context '#password_header' do
     it "returns a password hash for the request header" do
       ENV['HEADER_PASSWORD'] = 'foo'
-      Napa::Authentication.password_header.class.should eq(Hash)
-      Napa::Authentication.password_header.should eq('Password' => 'foo')
+      expect(Napa::Authentication.password_header.class).to eq(Hash)
+      expect(Napa::Authentication.password_header).to eq('Password' => 'foo')
     end
 
     it 'raises when the HEADER_PASSWORD env var is not defined' do
@@ -14,4 +14,4 @@ describe Napa::Authentication do
       expect{Napa::Authentication.password_header}.to raise_error
     end
   end
-end
+end

data/spec/deprecations/application_api_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'active_support'
+require 'napa/deprecations/application_api'
+
+describe Napa::Deprecations do
+  describe '.application_api_check' do
+    it 'does not raise a deprecation warning if the file exists' do
+      allow(File).to receive(:exists?).and_return(true)
+      expect(ActiveSupport::Deprecation).to_not receive(:warn)
+      Napa::Deprecations.application_api_check
+    end
+
+    it 'raises a deprecation warning if the file is missing' do
+      allow(File).to receive(:exists?).and_return(false)
+      expect(ActiveSupport::Deprecation).to receive(:warn)
+      Napa::Deprecations.application_api_check
+    end
+  end
+end

data/spec/deprecations/entity_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+require 'active_support'
+
+describe "Napa::Entity Deprecation" do
+  it 'raises a deprecation warning when a class inherits' do
+    expect(ActiveSupport::Deprecation).to receive(:warn)
+    class FooEntity < Napa::Entity; end
+  end
+end

data/spec/deprecations/filter_by_hash_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe "Napa::FilterByHash Deprecation" do
+  it 'raises a deprecation warning when mixed in to a class' do
+    expect(ActiveSupport::Deprecation).to receive(:warn)
+    class FooModel; include Napa::FilterByHash; end
+    ActiveSupport::Deprecation.silenced = false
+  end
+end

data/spec/deprecations/napa_setup_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'active_support'
+require 'napa/deprecations/napa_setup'
+
+describe Napa::Deprecations do
+  before do
+    allow(File).to receive(:exists?).and_return(true)
+
+    @apprb_stub = [
+      "require 'bundler/setup'",
+      "Bundler.setup(:default)",
+      "require 'napa/setup'",
+      "Bundler.require(:default, Napa.env.to_sym)",
+      "require 'napa'",
+      "Napa.load_environment",
+      "Dir['./config/initializers/**/*.rb'].map { |file| require file }",
+      "Dir['./config/middleware/**/*.rb'].map { |file| require file }",
+      "relative_load_paths = %w(app/apis app/entities app/models app/workers app/representers lib)",
+      "ActiveSupport::Dependencies.autoload_paths += relative_load_paths"
+    ]
+  end
+
+  describe '.napa_setup_check' do
+    it 'does not raise a deprecation warning if all the required_patterns are matched' do
+      allow(File).to receive(:readlines).with('./app.rb').and_return(@apprb_stub)
+      expect(ActiveSupport::Deprecation).to_not receive(:warn)
+      Napa::Deprecations.napa_setup_check
+    end
+
+    it 'raises a deprecation warning if any of the required_patterns are missing' do
+      (0..@apprb_stub.count - 1).each do |line_num|
+        apprb_missing_line = @apprb_stub
+        apprb_missing_line.delete_at(line_num)
+        allow(File).to receive(:readlines).with('./app.rb').and_return(apprb_missing_line)
+        expect(ActiveSupport::Deprecation).to receive(:warn)
+
+        Napa::Deprecations.napa_setup_check
+      end
+    end
+
+    it 'raises a deprecation warning if any of the expired_patterns are matched' do
+      Napa::Deprecations::EXPIRED_PATTERNS.each do |pattern|
+        app_rb_stub = [pattern]
+
+        allow(File).to receive(:readlines).with('./app.rb').and_return(app_rb_stub)
+        expect(ActiveSupport::Deprecation).to receive(:warn)
+
+        Napa::Deprecations.napa_setup_check
+      end
+    end
+  end
+end

data/spec/generators/api_generator_spec.rb

@@ -7,7 +7,7 @@ describe Napa::Generators::ApiGenerator do
   let(:test_api_directory) { 'spec/tmp' }
 
   before do
-    described_class.any_instance.stub(:output_directory) { test_api_directory }
+    allow_any_instance_of(described_class).to receive(:output_directory).and_return(test_api_directory)
     Napa::CLI::Base.new.generate("api", api_name)
   end
 

data/spec/generators/migration_generator_spec.rb

@@ -4,24 +4,102 @@ require 'napa/cli'
 
 describe Napa::Generators::MigrationGenerator do
 
-  let(:migration_name) { 'foo_bars' }
+  let(:migration_filename) { 'foo' }
   let(:test_migrations_directory) { 'spec/tmp' }
 
   before do
-    described_class.any_instance.stub(:output_directory) { test_migrations_directory }
+    allow_any_instance_of(described_class).to receive(:output_directory).and_return(test_migrations_directory)
+    allow_any_instance_of(described_class).to receive(:migration_filename).and_return(migration_filename)
   end
 
   after do
     FileUtils.rm_rf(test_migrations_directory)
   end
 
-  it 'creates a camelized migration class' do
-    described_class.any_instance.stub(:migration_filename) { 'foo' }
-    Napa::CLI::Base.new.generate("migration", migration_name)
-    expected_migration_file = File.join(test_migrations_directory, 'foo.rb')
-    migration_code = File.read(expected_migration_file)
-    expect(migration_code).to match(/class FooBars/)
+  describe 'AddFooToBar flew:string:index brew:integer' do
+    before do
+      Napa::CLI::Base.new.generate("migration", 'AddFooToBar', 'flew:string:index', 'brew:integer')
+      expected_migration_file = File.join(test_migrations_directory, 'foo.rb')
+      @migration_code = File.read(expected_migration_file)
+    end
+
+    it 'creates a camelized migration class' do
+      expect(@migration_code).to match(/class AddFooToBar/)
+    end
+
+    it 'adds the columns' do
+      expect(@migration_code).to match(/add_column :bars, :flew, :string/)
+      expect(@migration_code).to match(/add_column :bars, :brew, :integer/)
+    end
+
+    it 'adds the index on the correct column' do
+      expect(@migration_code).to match(/add_index :bars, :flew/)
+    end
+  end
+
+  describe 'RemoveFooFromBar flew:string brew:integer' do
+    before do
+      Napa::CLI::Base.new.generate("migration", 'RemoveFooFromBar', 'flew:string', 'brew:integer')
+      expected_migration_file = File.join(test_migrations_directory, 'foo.rb')
+      @migration_code = File.read(expected_migration_file)
+    end
+
+    it 'creates a camelized migration class' do
+      expect(@migration_code).to match(/class RemoveFooFromBar/)
+    end
+
+    it 'removes the columns' do
+      expect(@migration_code).to match(/remove_column :bars, :flew, :string/)
+      expect(@migration_code).to match(/remove_column :bars, :brew, :integer/)
+    end
+  end
+
+  describe 'CreateJoinTableFooBar foo bar' do
+    before do
+      Napa::CLI::Base.new.generate("migration", 'CreateJoinTableFooBar', 'foo', 'bar')
+      expected_migration_file = File.join(test_migrations_directory, 'foo.rb')
+      @migration_code = File.read(expected_migration_file)
+    end
+
+    it 'creates a camelized migration class' do
+      expect(@migration_code).to match(/class CreateJoinTableFooBar/)
+    end
+
+    it 'creates the join table' do
+      expect(@migration_code).to match(/create_join_table :foos, :bars/)
+    end
+
+    it 'adds placeholders for the indexing' do
+      expect(@migration_code).to match(/# t.index \[:foo_id, :bar_id\]/)
+      expect(@migration_code).to match(/# t.index \[:bar_id, :foo_id\]/)
+    end
+  end
+
+  describe 'CreateSkrillex drops:integer hair:string:index' do
+    before do
+      Napa::CLI::Base.new.generate("migration", 'CreateSkrillex', 'drops:integer', 'hair:string:index')
+      expected_migration_file = File.join(test_migrations_directory, 'foo.rb')
+      @migration_code = File.read(expected_migration_file)
+    end
+
+    it 'creates a camelized migration class' do
+      expect(@migration_code).to match(/class CreateSkrillex/)
+    end
+
+    it 'creates the table' do
+      expect(@migration_code).to match(/create_table :skrillexes/)
+    end
+
+    it 'adds the columns' do
+      expect(@migration_code).to match(/t.integer :drops/)
+      expect(@migration_code).to match(/t.string :hair/)
+    end
+
+    it 'adds the index on the correct column' do
+      expect(@migration_code).to match(/add_index :skrillexes, :hair/)
+    end
   end
 
+  describe 
 
 end

data/spec/generators/readme_generator_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'napa/generators/readme_generator'
+require 'napa/cli'
+
+describe Napa::Generators::ReadmeGenerator do
+  let(:test_readme_directory) { 'spec/tmp' }
+
+  before do
+    allow_any_instance_of(described_class).to receive(:output_directory).and_return(test_readme_directory)
+    Napa::CLI::Base.new.generate("readme")
+  end
+
+  after do
+    FileUtils.rm_rf(test_readme_directory)
+  end
+
+  describe 'README' do
+    it 'creates a README in the current directory' do
+      expected_readme_file = File.join(test_readme_directory, 'README.md')
+      readme = File.read(expected_readme_file)
+
+      expect(readme).to match /# #{Napa::Identity.name}/
+    end
+  end
+
+  describe 'spec' do
+    it 'creates a README spec' do
+      expected_spec_file = File.join(test_readme_directory, 'spec/docs/readme_spec.rb')
+      spec_code = File.read(expected_spec_file)
+
+      expect(spec_code).to match(/describe \'README\'/)
+    end
+  end
+
+end

data/spec/grape_extensions/error_formatter_spec.rb

@@ -6,16 +6,16 @@ describe Grape::ErrorFormatter::Json do
     it 'returns an api_error for plain error messages' do
       error = Grape::ErrorFormatter::Json.call('test message', nil)
       parsed = JSON.parse(error)
-      parsed['error']['code'].should eq('api_error')
-      parsed['error']['message'].should eq('test message')
+      expect(parsed['error']['code']).to eq('api_error')
+      expect(parsed['error']['message']).to eq('test message')
     end
 
     it 'returns a specified error when given a Napa::JsonError object' do
       json_error = Napa::JsonError.new(:foo, 'bar')
       error = Grape::ErrorFormatter::Json.call(json_error, nil)
       parsed = JSON.parse(error)
-      parsed['error']['code'].should eq('foo')
-      parsed['error']['message'].should eq('bar')
+      expect(parsed['error']['code']).to eq('foo')
+      expect(parsed['error']['message']).to eq('bar')
     end
 
     it 'adds the backtrace with rescue_option[:backtrace] specified' do
@@ -23,7 +23,7 @@ describe Grape::ErrorFormatter::Json do
                                                'backtrace',
                                                rescue_options: {backtrace: true})
       parsed = JSON.parse(error)
-      parsed['backtrace'].should eq('backtrace')
+      expect(parsed['backtrace']).to eq('backtrace')
     end
   end
-end
+end

data/spec/identity_spec.rb

@@ -5,46 +5,46 @@ describe Napa::Identity do
   context '#name' do
     it "returns 'api-service' if no ENV['SERVICE_NAME'] is set" do
       ENV['SERVICE_NAME'] = nil
-      Napa::Identity.name.should == 'api-service'
+      expect(Napa::Identity.name).to eq('api-service')
     end
 
     it "returns the ENV['SERVICE_NAME'] when specified" do
       ENV['SERVICE_NAME'] = nil
       ENV['SERVICE_NAME'] = 'my-service'
-      Napa::Identity.name.should eq('my-service')
+      expect(Napa::Identity.name).to eq('my-service')
     end
   end
 
   context '#hostname' do
     it 'returns the value of the hostname system call and doesn\'t make a second system call' do
-      Napa::Identity.should_receive(:`).with('hostname').and_return('system-hostname')
-      Napa::Identity.hostname.should eq('system-hostname')
+      expect(Napa::Identity).to receive(:`).with('hostname').and_return('system-hostname')
+      expect(Napa::Identity.hostname).to eq('system-hostname')
 
-      Napa::Identity.should_not_receive(:`).with('hostname')
-      Napa::Identity.hostname.should eq('system-hostname')
+      expect(Napa::Identity).to_not receive(:`).with('hostname')
+      expect(Napa::Identity.hostname).to eq('system-hostname')
     end
   end
 
   context '#revision' do
     it 'returns the value of the \'git rev-parse HEAD\' system call and doesn\'t make a second system call' do
-      Napa::Identity.should_receive(:`).with('git rev-parse HEAD').and_return('12345')
-      Napa::Identity.revision.should eq('12345')
+      expect(Napa::Identity).to receive(:`).with('git rev-parse HEAD').and_return('12345')
+      expect(Napa::Identity.revision).to eq('12345')
 
-      Napa::Identity.should_not_receive(:`).with('git rev-parse HEAD')
-      Napa::Identity.revision.should eq('12345')
+      expect(Napa::Identity).to_not receive(:`).with('git rev-parse HEAD')
+      expect(Napa::Identity.revision).to eq('12345')
     end
   end
 
   context '#pid' do
     it 'returns the process ID value' do
-      Process.stub(:pid).and_return(112233)
-      Napa::Identity.pid.should be(112233)
+      allow(Process).to receive(:pid).and_return(112233)
+      expect(Napa::Identity.pid).to eq(112233)
     end
   end
 
   context '#platform_revision' do
     it 'returns the current version of the platform gem' do
-      Napa::Identity.platform_revision.should == Napa::VERSION
+      expect(Napa::Identity.platform_revision).to eq(Napa::VERSION)
     end
   end
 end

data/spec/json_error_spec.rb

@@ -7,8 +7,8 @@ describe Napa::JsonError do
       error = Napa::JsonError.new(:code, 'message').to_json
       parsed = JSON.parse(error)
 
-      parsed['error']['code'].should eq('code')
-      parsed['error']['message'].should eq('message')
+      expect(parsed['error']['code']).to eq('code')
+      expect(parsed['error']['message']).to eq('message')
     end
   end
-end
+end

data/spec/logger/log_transaction_spec.rb

@@ -10,25 +10,25 @@ describe Napa::LogTransaction do
     it 'returns the current transaction id if it has been set' do
       id = SecureRandom.hex(10)
       Thread.current[:napa_tid] = id
-      Napa::LogTransaction.id.should == id
+      expect(Napa::LogTransaction.id).to eq(id)
     end
 
     it 'sets and returns a new id if the transaction id hasn\'t been set' do
-      Napa::LogTransaction.id.should_not be_nil
+      expect(Napa::LogTransaction.id).to_not be_nil
     end
 
     it 'allows the id to be overridden by a setter' do
-      Napa::LogTransaction.id.should_not be_nil
+      expect(Napa::LogTransaction.id).to_not be_nil
       Napa::LogTransaction.id = 'foo'
-      Napa::LogTransaction.id.should == 'foo'
+      expect(Napa::LogTransaction.id).to eq('foo')
     end
   end
 
   context '#clear' do
     it 'sets the id to nil' do
-      Napa::LogTransaction.id.should_not be_nil
+      expect(Napa::LogTransaction.id).to_not be_nil
       Napa::LogTransaction.clear
-      Thread.current[:napa_tid].should be_nil
+      expect(Thread.current[:napa_tid]).to be_nil
     end
   end
 end

data/spec/middleware/authentication_spec.rb

@@ -14,7 +14,7 @@ describe Napa::Identity do
       env = Rack::MockRequest.env_for('/test', {'HTTP_PASSWORD' => 'foo'})
       status, headers, body = middleware.call(env)
 
-      status.should be(200)
+      expect(status).to eq(200)
     end
   end
 
@@ -25,8 +25,8 @@ describe Napa::Identity do
       env = Rack::MockRequest.env_for('/test')
       status, headers, body = middleware.call(env)
 
-      status.should be(401)
-      body.should eq([Napa::JsonError.new('bad_password', 'bad password').to_json])
+      expect(status).to eq(401)
+      expect(body).to eq([Napa::JsonError.new('bad_password', 'bad password').to_json])
     end
 
     it 'returns an error message if an incorrect Password header is supplied' do
@@ -35,8 +35,8 @@ describe Napa::Identity do
       env = Rack::MockRequest.env_for('/test', {'HTTP_PASSWORD' => 'incorrect'})
       status, headers, body = middleware.call(env)
 
-      status.should be(401)
-      body.should eq([Napa::JsonError.new('bad_password', 'bad password').to_json])
+      expect(status).to eq(401)
+      expect(body).to eq([Napa::JsonError.new('bad_password', 'bad password').to_json])
     end
 
     it 'returns an error message if HEADER_PASSWORDS is not configured' do
@@ -47,8 +47,8 @@ describe Napa::Identity do
       env = Rack::MockRequest.env_for('/test', {'HTTP_PASSWORD' => 'incorrect'})
       status, headers, body = middleware.call(env)
 
-      status.should be(401)
-      body.should eq([Napa::JsonError.new('not_configured', 'password not configured').to_json])
+      expect(status).to eq(401)
+      expect(body).to eq([Napa::JsonError.new('not_configured', 'password not configured').to_json])
     end
   end
-end
+end

data/spec/middleware/database_stats_spec.rb

@@ -35,29 +35,29 @@ describe Napa::Middleware::DatabaseStats do
   end
 
   it 'should send a query_time for an insert' do
-    Napa::Stats.emitter.should_receive(:timing).with('sql.query_time', an_instance_of(Float))
-    Napa::Stats.emitter.should_receive(:timing).with('sql.table.foos.insert.query_time', an_instance_of(Float))
+    allow(Napa::Stats.emitter).to receive(:timing).with('sql.query_time', an_instance_of(Float))
+    allow(Napa::Stats.emitter).to receive(:timing).with('sql.table.foos.insert.query_time', an_instance_of(Float))
 
     @app = lambda { |env| [200, { 'Content-Type' => 'application/json' }, Foo.create(word: 'baz')] }
   end
 
   it 'should send a query_time for a select' do
-    Napa::Stats.emitter.should_receive(:timing).with('sql.query_time', an_instance_of(Float))
-    Napa::Stats.emitter.should_receive(:timing).with('sql.table.foos.select.query_time', an_instance_of(Float))
+    allow(Napa::Stats.emitter).to receive(:timing).with('sql.query_time', an_instance_of(Float))
+    allow(Napa::Stats.emitter).to receive(:timing).with('sql.table.foos.select.query_time', an_instance_of(Float))
 
     @app = lambda { |env| [200, { 'Content-Type' => 'application/json' }, Foo.first] }
   end
 
   it 'should send a query_time for a delete' do
-    Napa::Stats.emitter.should_receive(:timing).with('sql.query_time', an_instance_of(Float))
-    Napa::Stats.emitter.should_receive(:timing).with('sql.table.foos.delete.query_time', an_instance_of(Float))
+    allow(Napa::Stats.emitter).to receive(:timing).with('sql.query_time', an_instance_of(Float))
+    allow(Napa::Stats.emitter).to receive(:timing).with('sql.table.foos.delete.query_time', an_instance_of(Float))
 
     @app = lambda { |env| [200, { 'Content-Type' => 'application/json' }, @foo.delete ] }
   end
 
   it 'should send a query_time for an update' do
-    Napa::Stats.emitter.should_receive(:timing).with('sql.query_time', an_instance_of(Float))
-    Napa::Stats.emitter.should_receive(:timing).with('sql.table.foos.update.query_time', an_instance_of(Float))
+    allow(Napa::Stats.emitter).to receive(:timing).with('sql.query_time', an_instance_of(Float))
+    allow(Napa::Stats.emitter).to receive(:timing).with('sql.table.foos.update.query_time', an_instance_of(Float))
 
     @app = lambda { |env| [200, { 'Content-Type' => 'application/json' }, @foo.update_attributes(word: 'baz') ] }
   end

data/spec/middleware/request_stats_spec.rb

@@ -9,18 +9,9 @@ describe Napa::Middleware::RequestStats do
     ENV['STATSD_PORT'] = '8125'
   end
 
-  it 'should increment api_requests counter' do
-    Napa::Stats.emitter.should_receive(:increment).with('request_count')
-    Napa::Stats.emitter.should_receive(:increment).with('path.get.test.path.request_count')
-    app = lambda { |env| [200, { 'Content-Type' => 'application/json' }, Array.new] }
-    middleware = Napa::Middleware::RequestStats.new(app)
-    env = Rack::MockRequest.env_for('/test/path')
-    middleware.call(env)
-  end
-
   it 'should send the api_response_time' do
-    Napa::Stats.emitter.should_receive(:timing).with('response_time', an_instance_of(Float))
-    Napa::Stats.emitter.should_receive(:timing).with('path.get.test.path.response_time', an_instance_of(Float))
+    expect(Napa::Stats.emitter).to receive(:timing).with('response_time', an_instance_of(Float))
+    expect(Napa::Stats.emitter).to receive(:timing).with('path.get.test.path.response_time', an_instance_of(Float))
     app = lambda { |env| [200, { 'Content-Type' => 'application/json'}, Array.new] }
     middleware = Napa::Middleware::RequestStats.new(app)
     env = Rack::MockRequest.env_for('/test/path')

data/spec/spec_helper.rb

@@ -1,11 +1,20 @@
-require 'napa'
-
 ENV['RACK_ENV'] = 'test'
 
+require 'napa/setup'
+
+Napa.skip_initialization = true
+
+require 'napa'
+
 # from https://gist.github.com/adamstegman/926858
 RSpec.configure do |config|
   config.before(:all) { silence_output }
   config.after(:all) { enable_output }
+
+  config.before(:each) do
+    allow(Napa).to receive(:initialize)
+    allow(Napa::Logger).to receive_message_chain('logger.info').with(:napa_deprecation_warning)
+  end
 end
 
 # Redirects stderr and stdout to /dev/null.

data/spec/stats_d_timer_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'napa/stats_d_timer'
+
+class FooTimer
+  include Napa::StatsDTimer
+end
+
+describe Napa::StatsDTimer do
+  before do
+    # Delete any prevous instantiations of the emitter
+    Napa::Stats.emitter = nil
+    # Stub out logging since there is no log to output to
+    allow(Napa::Logger).to receive_message_chain(:logger, :warn)
+  end
+
+  it 'logs a timing event based on how long the block takes' do
+    expect(Napa::Stats.emitter).to receive(:timing).with('foo', an_instance_of(Float))
+    FooTimer.report_time('foo') do
+      sleep(0.1)
+    end
+  end
+
+end

data/spec/stats_spec.rb

@@ -6,14 +6,14 @@ describe Napa::Stats do
     # Delete any prevous instantiations of the emitter
     Napa::Stats.emitter = nil
     # Stub out logging since there is no log to output to
-    Napa::Logger.stub_chain(:logger, :warn)
+    allow(Napa::Logger).to receive_message_chain(:logger, :warn)
   end
 
   it 'should log an error if StatsD env variables are not configured' do
     ENV['STATSD_HOST'] = nil
     ENV['STATSD_PORT'] = nil
     message = 'StatsD host and port not configured in environment variables, using default settings'
-    Napa::Logger.logger.should_receive(:warn).with(message)
+    expect(Napa::Logger.logger).to receive(:warn).with(message)
     Napa::Stats.emitter
   end