nogo 1.0.0.beta

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.rvmrc
+.rspec

data/Gemfile

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

data/README.md

@@ -0,0 +1,75 @@
+### NoGo is a library to find the places in your code which touch your database
+NoGo's main objective is to help find and prevent code which accesses the database during testing.  Disconnecting the database completely while running your test suite may be impractical, so NoGo take a different approach by proxying an estabished database connection.  It is possible to enable and disable NoGo as well as change between ```:raise```, ```:warn``` and ```:pass_through``` strategies on the fly.
+
+## Installation
+Add nogo to your Gemfile
+
+```gem 'nogo'```
+
+Or install from the command line
+
+```gem install nogo```
+
+## Usage
+
+NoGo can be used as a standalone library, but it does integrate with the RSpec 2 test framework.
+
+### RSpec
+Wrap any spec examples that should not use the database adapter inside a "nogo do" block.
+
+<pre>
+# In your specs
+require 'nogo/rspec' # Automatically connects, so this should be included after the environment is loaded.
+
+describe Klass do
+  it 'works without error' do
+    Klass.create
+  end
+
+  nogo do # Any access to the database inside this block will raise an exception
+    it 'raises error' do
+      expect{ Klass.create }.to raise_error
+    end
+  end
+
+  it 'works without error' do
+    Klass.create
+  end
+end
+</pre>
+
+### Globally enabling NoGo
+By default NoGo will not check requests to the database, even after being connected.  Here is an example of enabling NoGo.
+
+<pre>
+require 'nogo'
+
+# Database adapter should already be connected
+NoGo::Connection.connect!
+
+ModelKlass.create                   # Works as expected
+
+NoGo::Connection.enabled = true
+ModelKlass.create                   # Raises exception
+
+NoGo::Connection.enabled = false
+ModelKlass.create                   # Works as expected
+</pre>
+
+## Platforms
+Tested with:
+
+RSpec 2.7.0, 2.8.0
+ActiveRecord 3.1.3, 3.2.1.
+
+##LICENSE
+
+(The MIT License)
+
+Copyright © 2012 Andy Ogzewalla
+
+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/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/active_record/connection_adapters/nogo_adapter.rb

@@ -0,0 +1,15 @@
+# Adds a connection method so that ActiveRecord recognizes the proxy adapter
+module ActiveRecord
+  class Base
+    # returns an instance of <tt>NoGo::ProxyAdapter</tt> which proxies the adapter instance specified by <tt>config[:target_adapter]</tt>.  This method will 
+    # also attempt to reconnect the proxied adapter.
+    def self.nogo_connection(config)
+      proxy_adapter = NoGo::ProxyAdapter.new(config[:target_adapter])
+      proxy_adapter.proxied_adapter.send :connect # TODO: It would be nice if we could detect whether the adapter was connected before, but for now just attempt to reconnect it. ActiveRecord disconnects the adapter before calling <tt>::nogo_connection</tt> *
+      # TODO: This is probably where connection pool config should be set rather than in NoGo::Connection::connect! *
+      proxy_adapter
+    end
+  end
+end
+
+require 'active_record/import'

data/lib/active_record/import.rb

@@ -0,0 +1,13 @@
+if defined?(ActiveRecord::Import)
+  ActiveRecord::Import.module_eval do
+    class << self # Lulz, I tried `module << self` which didn't work.
+      # Catch case where adapter is set to <tt>:nogo</tt>.  Activerecord-import hijacks 
+      # AR::Base#establish_connection, so there was no clean way to avoid having it attempt
+      # to require its own nogo adatper, which fails.
+      def require_adapter_with_nogo(adapter)
+        require_adapter_without_nogo(adapter) unless adapter==:nogo
+      end
+      alias_method_chain :require_adapter, :nogo
+    end
+  end
+end

data/lib/nogo.rb

@@ -0,0 +1,4 @@
+require 'nogo/version'
+require 'nogo/abstract_method_overrides'
+require 'nogo/proxy_adapter'
+require 'nogo/connection'

data/lib/nogo/abstract_method_overrides.rb

@@ -0,0 +1,78 @@
+module NoGo
+  # Contains overrides for methods which are defined in ActiveRecord::ConnectionAdapters::AbstractAdapter and are 
+  # ovenrridden here as a way to hook into ActiveRecord before requests access the database connection.
+  module AbstractMethodOverrides
+
+    def execute(sql, name = nil)
+      if sql.match /BEGIN|ROLLBACK|SAVEPOINT/ # TODO: There should be a better way to avoid transactions *
+        pass_through(:execute, sql, name)
+      else
+        raise_or_pass_through(:execute, sql, name)
+      end      
+    end
+
+    def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
+      raise_or_pass_through(:insert, sql, name, pk, id_value, sequence_name, binds)
+    end
+
+    def update(sql, name = nil, binds = [])
+      raise_or_pass_through(:update, sql, name, binds)
+    end
+
+    def delete(sql, name = nil, binds = [])
+      raise_or_pass_through(:delete, sql, name, binds)
+    end
+
+    def select_rows(sql, name = nil)
+      raise_or_pass_through(:select_rows, sql, name)
+    end
+
+    def select(sql, name = nil)
+      raise_or_pass_through(:select, sql, name)
+    end
+
+    def select_all(sql, name = nil, binds = [])
+      raise_or_pass_through(:select_all, sql, name, binds)
+    end
+
+    def select_one(sql, name = nil)
+      raise_or_pass_through(:select_one, sql, name)
+    end
+
+    def select_value(sql, name = nil)
+      raise_or_pass_through(:select_value, sql, name)
+    end
+
+    def select_values(sql, name = nil)
+      raise_or_pass_through(:select_values, sql, name)
+    end
+
+    def exec_query(sql, name = nil, binds = [])
+      raise_or_pass_through(:exec_query, sql, name, binds)
+    end
+
+    def exec_insert(sql, name = nil, binds = [])
+      raise_or_pass_through(:exec_insert, sql, name, binds)
+    end
+
+    def exec_delete(sql, name = nil, binds = [])
+      raise_or_pass_through(:exec_delete, sql, name, binds)
+    end
+
+    def exec_update(sql, name = nil, binds = [])
+      raise_or_pass_through(:exec_update, sql, name, binds)
+    end
+
+    def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
+      raise_or_pass_through(:insert_sql, sql, name, pk, id_value, sequence_name, binds)
+    end
+
+    def update_sql(sql, name = nil)
+      raise_or_pass_through(:update_sql, sql, name)
+    end
+
+    def delete_sql(sql, name = nil)
+      raise_or_pass_through(:delete_sql, sql, name)
+    end
+  end
+end

data/lib/nogo/connection.rb

@@ -0,0 +1,47 @@
+module NoGo
+  class Connection
+    @@proxy_adapter = nil
+
+    # Returns proxy adapter if connected, otherwise raises an error
+    def self.proxy_adapter
+      @@proxy_adapter || raise('Proxy adapter is not connected.  Please run NoGo::Connection.connect! to first establish a connection.')
+    end
+
+    # Proxy an existing connection.  Raises an exception if no database
+    # connection has been established.
+    def self.connect!
+      # TODO: Abstract away ORM-specific code *
+      original_adapter = ActiveRecord::Base.connection_pool.spec.config[:adapter]
+      ActiveRecord::Base.establish_connection :adapter => :nogo, :target_adapter => ActiveRecord::Base.connection
+
+      # After establishing connection the connection pool config adapter will be set to <tt>:nogo</tt> which
+      # may cause problems with gems such as activerecord-import which rely on that value to be set to a
+      # standard ActiveRecord database adapter.  Fortunately we can easily change the config setting back to
+      # its original value.
+      ActiveRecord::Base.connection_pool.spec.config[:adapter] = original_adapter 
+            
+      @@proxy_adapter = ActiveRecord::Base.connection
+    end
+
+    # Returns true or false to indicate whether a proxy adapter has been connected.
+    def self.connected?
+      !!@@proxy_adapter
+    end
+
+    def self.enabled=(value)
+      proxy_adapter.enabled = value
+    end
+
+    def self.pop_enabled_state
+      proxy_adapter.pop_enabled_state
+    end
+
+    def self.push_enabled_state
+      proxy_adapter.push_enabled_state
+    end
+
+    def self.strategy=(strategy)
+      proxy_adapter.strategy = strategy
+    end
+  end
+end

data/lib/nogo/proxy_adapter.rb

@@ -0,0 +1,90 @@
+module NoGo
+  class ProxyAdapter  
+    # Valid values for <tt>@strategy</tt> and arguments when setting <tt>strategy</tt>
+    StrategyOptions = [:raise, :warn, :pass_through].freeze
+
+    ErrorMessageForRaiseStrategy = <<-EOM.freeze
+      Access to the database adapter is currently restricted (strategy set to :raise).
+      Set strategy to :pass_through or :warn to allow database access.  See NoGo::Connection#strategy=.
+    EOM
+
+    # Most methods calls should simply be passed on to the proxied adapter.  By undefining most methods we can use 
+    # <tt>method_missing</tt> to accomplish this.
+    instance_methods.each do |method_name| 
+      undef_method method_name unless method_name =~ /^__|^send$|^object_id$|^extend|^tap|^instance_variable_set|^instance_variable_get/ 
+    end
+
+    attr_accessor :enabled
+
+    # Include overriden AbstractAdapter methods
+    include NoGo::AbstractMethodOverrides
+
+    # Initializes an instance and sets the proxied adapter and default strategy.  An exception is raised if the argument to <tt>adapter</tt> is 
+    # not an instance of <tt>ActiveRecord::ConnectionAdapters::AbstractAdapter</tt>.
+    def initialize(adapter)
+      raise ArgumentError.new(
+        "Expected an instance of ActiveRecord::ConnectionAdapters::AbstractAdapter, but received #{adapter.class.name}"
+      ) unless adapter.is_a?(ActiveRecord::ConnectionAdapters::AbstractAdapter)
+
+      @adapter = adapter
+      @strategy = :raise
+      self.enabled = false
+      @enabled_state_stack = []
+    end
+
+    # Pops the last value from <tt>enabled_state_stack</tt> and assigns it to <tt>enabled</tt>.
+    def pop_enabled_state
+      self.enabled = @enabled_state_stack.pop || false
+    end
+
+    # Pushes the current value of <tt>enabled</tt> onto <tt>enabled_state_stack</tt>.
+    def push_enabled_state
+      @enabled_state_stack.push(enabled)
+    end
+
+    # Returns the adapter which is being proxied by the current object.
+    def proxied_adapter
+      @adapter
+    end
+
+    # Returns the current strategy assigned to this adapter, which can any of the <tt>StrategyOptions</tt>.
+    def strategy
+      @strategy
+    end
+
+    # Sets the current strategy for this adapter.  Raises an <tt>ArgumentErrer</tt> if <tt>strategy_option</tt> is not
+    # a value from <tt>StrategyOptions</tt>
+    def strategy=(strategy_option)
+      raise ArgumentError.new(
+        "Expected strategy to be set to one of [#{StrategyOptions.map{|opt| ":#{opt}"}.join(', ')}], but received #{strategy_option}"
+      ) unless StrategyOptions.include?(strategy_option.to_sym)
+
+      @strategy = strategy_option
+    end
+
+    private
+
+    # Pass through any undefined instance method calls.
+    def method_missing(method_name, *args, &block)  # :doc:
+      pass_through(method_name, *args, &block)
+    end
+
+    # Passes a method call to the proxied adapter.
+    # If the strategy is set to <tt>:warn</tt> then <tt>#warn</tt> will be invoked.
+    def pass_through(method_name, *args, &block) # :doc: 
+      warn(method_name, *args, &block) if enabled && @strategy == :warn
+      proxied_adapter.send(method_name, *args, &block)
+    end
+
+    # Raises an error if the current strategy is <tt>:raise</tt> and otherwise defers the method call to <tt>#pass_through</tt>.
+    def raise_or_pass_through(method_name, *args, &block) # :doc:
+      raise ErrorMessageForRaiseStrategy if enabled && @strategy == :raise
+      pass_through(method_name, *args, &block)
+    end
+
+    # Placeholder for <tt>#warn</tt> method.  This is probably a place to trigger hooks once they are supported
+    def warn(method_name, *args, &block) # :doc:
+      puts "\nDatabase adapter accessed from: " + Kernel.caller[0..12].join("\n")
+    end
+  end
+end

data/lib/nogo/rspec.rb

@@ -0,0 +1,4 @@
+require_relative '../nogo'
+require_relative 'rspec/dsl'
+
+NoGo::Connection::connect!

data/lib/nogo/rspec/dsl.rb

@@ -0,0 +1,31 @@
+require 'rspec'
+
+module NoGo
+  module RSpec
+    class DSL
+      NogoBeforeAllBlock = Proc.new do
+        NoGo::Connection.push_enabled_state
+        NoGo::Connection.enabled = true
+      end.freeze
+      NogoAfterAllBlock = Proc.new do
+        NoGo::Connection.pop_enabled_state
+      end.freeze
+
+      def self.nogo_example_group(*args, &example_group_block)
+        ::RSpec::Core::ExampleGroup.describe(*args) do
+          before(:all, &NoGo::RSpec::DSL::NogoBeforeAllBlock)
+          after(:all, &NoGo::RSpec::DSL::NogoAfterAllBlock)
+          instance_eval(&example_group_block)
+        end
+      end
+    end
+  end
+end
+
+# Adds DSL method to RSpec ExampleGroup instances
+RSpec::Core::DSL.module_eval do
+  def nogo(*args, &example_group_block)
+    NoGo::RSpec::DSL.nogo_example_group(*args, &example_group_block).register
+  end
+  alias :database_restricted :nogo
+end

data/lib/nogo/version.rb

@@ -0,0 +1,3 @@
+module NoGo
+  VERSION = "1.0.0.beta"
+end

data/nogo.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/nogo/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Andy Ogzewalla"]
+  gem.email         = ["andyogzewalla@gmail.com"]
+  gem.description   = %q{A library that lets you know when your code touches your database}
+  gem.summary       = %q{A library that lets you know when your code touches your database}
+  gem.homepage      = ""
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "nogo"
+  gem.require_paths = ["lib"]
+  gem.version       = NoGo::VERSION
+
+  gem.add_dependency 'rspec', '~> 2.7.0'
+  gem.add_dependency 'activerecord', '~> 3.0'
+  gem.add_development_dependency 'rspec', '~> 2.7.0'
+  gem.add_development_dependency 'activerecord', '~> 3.0'
+end

data/spec/active_record/connection_adapters/nogo_adapter_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'active_record/connection_adapters/nogo_adapter'
+
+describe ActiveRecord::Base do
+  describe '::nogo_connection' do
+    let(:adapter) { mock }
+    let(:nogo_adapter) { mock(:proxied_adapter => adapter) }
+
+    before :each do
+      NoGo::ProxyAdapter.stub(:new).with(adapter).and_return(nogo_adapter)
+    end
+
+    it 'returns new NoGo::ProxyAdapter instance' do
+      adapter.stub(:connect)
+      ActiveRecord::Base.nogo_connection({:target_adapter => adapter}).should == nogo_adapter
+    end
+
+    it 'reconnects the adapter' do
+      adapter.should_receive(:connect)
+      ActiveRecord::Base.nogo_connection({:target_adapter => adapter})
+    end
+  end
+
+end

data/spec/nogo/connection_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe NoGo::Connection do
+  subject { NoGo::Connection }
+  let(:proxy_adapter) { mock.as_null_object }
+  before :each do
+    subject.class_variable_set(:@@proxy_adapter, proxy_adapter)
+  end
+
+  describe '::proxy_adapter' do
+    let(:proxy_adapter) {mock}
+
+    before :each do
+      subject.class_variable_set(:@@proxy_adapter, proxy_adapter)
+    end
+
+    it 'raises error if proxy adapter is not connected' do
+      subject.class_variable_set(:@@proxy_adapter, nil)
+      expect{subject.proxy_adapter}.to raise_error
+    end
+
+    it 'does not raise an error if proxy adapter is connected' do
+      subject.class_variable_set(:@@proxy_adapter, proxy_adapter)
+      expect{subject.proxy_adapter}.to_not raise_error
+    end
+
+    it 'returns proxy adapter if connected' do
+      subject.class_variable_set(:@@proxy_adapter, proxy_adapter)
+      subject.proxy_adapter.should == proxy_adapter
+    end
+  end
+
+  describe '::connect!' do
+    it 'raise an error if ActiveRecord is not connected to a database' do
+      ActiveRecord::Base.stub(:connection).and_raise(ActiveRecord::ConnectionNotEstablished.new)
+      expect{subject.connect!}.to raise_error(ActiveRecord::ConnectionNotEstablished)
+    end
+
+    context do
+      let(:adapter) { ActiveRecord::ConnectionAdapters::AbstractAdapter.new(nil)}
+      let(:config) {{:adapter => 'original_adapter'}}
+      
+      before :each do
+        adapter.stub(:connect)
+        ActiveRecord::Base.stub(:connection) { adapter }
+        ActiveRecord::Base.stub(:connection_pool) { mock(:spec => mock(:config => config)) }
+      end
+
+      it 'proxies the current connection adapter' do
+        ActiveRecord::Base.should_receive(:establish_connection).
+          with(:adapter => :nogo, :target_adapter => adapter)
+        subject.connect!
+      end
+
+      it 'sets @@proxy_adapter with instance of NoGo::ProxyAdapter generated when establishing connection' do
+        subject.connect!
+        subject.class_variable_get(:@@proxy_adapter).should == adapter
+      end
+
+      it 'sets connection_pool spec config adapter to original (non-proxied) value' do
+        config.should_receive(:[]=).with(:adapter, 'original_adapter')
+        subject.connect!
+      end
+    end
+  end
+
+  describe '::connected?' do
+    it 'returns false if proxy adapter has not been connected' do
+      subject.class_variable_set(:@@proxy_adapter, nil)
+      subject.connected?.should == false
+    end
+
+    it 'returns true if proxy adapter has been connected' do
+      subject.connected?.should == true
+    end    
+  end
+
+  describe '::enabled=' do
+    it 'invokes #enabled= with argument on proxy adapter' do
+      argument = mock
+      proxy_adapter.should_receive(:enabled=).with(argument)
+      subject.enabled = argument
+    end
+  end
+
+  describe '::strategy=' do
+    it 'calls #strategy= on the proxy adapter' do
+      proxy_adapter.should_receive(:strategy=).with(:pass_through)
+      subject.strategy = :pass_through
+    end
+  end
+
+  describe '::pop_enabled_state' do
+    it 'invokes #pop_enabled_state on the proxy adapter' do
+      proxy_adapter.should_receive(:pop_enabled_state)
+      subject.pop_enabled_state
+    end
+  end
+
+  describe '::push_enabled_state' do
+    it 'invokes #push_enabled_state on the proxy adapter' do
+      proxy_adapter.should_receive(:push_enabled_state)
+      subject.push_enabled_state
+    end
+  end
+end

data/spec/nogo/proxy_adapter_spec.rb

@@ -0,0 +1,352 @@
+require 'spec_helper'
+
+describe NoGo::ProxyAdapter do
+  let(:adapter) { ActiveRecord::ConnectionAdapters::AbstractAdapter.new(nil)}
+  let(:proxy_adapter) { NoGo::ProxyAdapter.new(adapter) }
+
+  before :all do
+    NoGo::ProxyAdapter.class_eval do
+
+      # Ugh, rspec mocks freak out if we try to pass calls to
+      def is_a?(klass)
+        proxied_adapter.is_a?(klass)
+      end
+
+      private
+      def method_missing_with_test_filter(method_name, *args, &block)
+        # RSpec sends messages directly to method_missing when checking an object with mocked methods.  Why?  I don't know, but it 
+        # causes an infinite loop for some of ProxyAdapter methods.  This filter prevents that from happening.
+        unless %W[warn pass_through method_missing].include?(method_name.to_s)
+          method_missing_without_test_filter(method_name, *args, &block)
+        end
+      end
+      alias_method_chain :method_missing, :test_filter
+    end
+  end
+
+  describe '::new' do
+    it 'initializes with adapter argument' do
+      expect{ NoGo::ProxyAdapter.new(adapter) }.to_not raise_error
+    end
+
+    it 'raises error without adapter argument' do
+      expect{ NoGo::ProxyAdapter.new }.to raise_error(ArgumentError)
+    end
+
+    it 'raises error when adapter argument is not an instance of AbstractAdapter' do
+      expect{ NoGo::ProxyAdapter.new(Object.new) }.to raise_error(ArgumentError)
+    end
+
+    it 'initializes @strategy to :raise' do
+      NoGo::ProxyAdapter.new(adapter).instance_variable_get(:@strategy).should == :raise
+    end
+  end
+
+  it 'passes undefined instance method calls through to the adapter' do
+    adapter.should_receive(:method_name).with(:arg)
+    proxy_adapter.method_name :arg
+  end
+
+  it 'initializes enabled to false' do
+    NoGo::ProxyAdapter.new(adapter).enabled.should == false
+  end
+
+  it 'initializes enabled_state_stack to []' do
+    NoGo::ProxyAdapter.new(adapter).instance_variable_get(:@enabled_state_stack).should == []
+  end
+
+  describe '#proxied_adapter' do
+    it 'returns adapter' do
+      proxy_adapter.proxied_adapter.should == adapter
+    end
+  end
+
+  describe '#is_a?' do
+    it 'invokes method on proxied adapter' do
+      adapter.stub(:is_a?).with(ActiveRecord::ConnectionAdapters::AbstractAdapter) { true }
+      adapter.should_receive(:is_a?).with(Class)
+      proxy_adapter.is_a?(Class)
+    end
+  end
+
+  describe '#pop_enabled_state' do
+    it 'assigns true to enabled when last value on the stack is true' do
+      proxy_adapter.instance_variable_set(:@enabled_state_stack, [true])
+      proxy_adapter.enabled = nil
+      proxy_adapter.pop_enabled_state
+      proxy_adapter.enabled.should == true
+    end
+
+    it 'assigns false to enabled when last value on the stack is false' do
+      proxy_adapter.instance_variable_set(:@enabled_state_stack, [false])
+      proxy_adapter.enabled = nil
+      proxy_adapter.pop_enabled_state
+      proxy_adapter.enabled.should == false
+    end
+
+    it 'assigns false to enabled when stack is empty' do
+      proxy_adapter.instance_variable_set(:@enabled_state_stack, [])
+      proxy_adapter.enabled = nil
+      proxy_adapter.pop_enabled_state
+      proxy_adapter.enabled.should == false
+    end
+  end
+
+  describe '#push_enabled_state' do
+    it 'pushes true to the stack when enabled is true' do
+      proxy_adapter.instance_variable_set(:@enabled_state_stack, [])
+      proxy_adapter.enabled = true
+      proxy_adapter.push_enabled_state
+      proxy_adapter.instance_variable_get(:@enabled_state_stack).should == [true]
+    end
+
+    it 'pushes false to the stack when enabled is false' do
+      proxy_adapter.instance_variable_set(:@enabled_state_stack, [])
+      proxy_adapter.enabled = false
+      proxy_adapter.push_enabled_state
+      proxy_adapter.instance_variable_get(:@enabled_state_stack).should == [false]
+    end
+  end
+
+  describe '#strategy' do
+    NoGo::ProxyAdapter::StrategyOptions.each do |strategy_option|
+      it "returns :#{strategy_option}" do
+        proxy_adapter.instance_variable_set(:@strategy, strategy_option)
+        proxy_adapter.strategy.should == strategy_option
+      end
+    end
+  end
+
+  describe '#strategy=' do
+    NoGo::ProxyAdapter::StrategyOptions.each do |strategy_option|
+      it "sets :#{strategy_option} strategy" do
+        proxy_adapter.strategy = strategy_option
+        proxy_adapter.strategy.should == strategy_option
+      end
+    end
+
+    it 'raises an exception if the strategy option is not valid' do
+      expect{ proxy_adapter.strategy = :invalid_option }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#pass_through' do
+    it 'uoea' do
+      proxy_adapter.should_receive(:bleh).with(:m, :a)
+      proxy_adapter.bleh :m, :a
+    end
+
+    it 'sends method call and arguments to @adapter' do
+      adapter.should_receive(:method_name).with(:arg)
+      proxy_adapter.send :pass_through, :method_name, :arg
+    end
+
+    context 'when strategy is :warn' do
+      before :each do
+        proxy_adapter.strategy = :warn
+      end
+
+      it 'invokes #warn when enabled' do
+        proxy_adapter.enabled = true
+        adapter.stub(:method_name)
+        proxy_adapter.should_receive(:warn).with(:method_name, :arg)
+        proxy_adapter.send :pass_through, :method_name, :arg
+      end
+
+      it 'does not invoke #warn when disabled' do
+        proxy_adapter.enabled = false
+        adapter.stub(:method_name)
+        proxy_adapter.should_not_receive(:warn).with(:method_name, :arg)
+        proxy_adapter.send :pass_through, :method_name, :arg
+      end
+    end
+
+    it 'does not invoke #warn when strategy is :pass_through' do
+      proxy_adapter.strategy = :pass_through
+      adapter.stub(:method_name)
+      proxy_adapter.should_not_receive(:warn).with(:method_name, :arg)
+      proxy_adapter.send :pass_through, :method_name, :arg
+    end
+  end
+
+  describe '#raise_or_pass_through' do
+    context 'when strategy is set to :raise' do
+      before :each do
+        proxy_adapter.strategy = :raise
+      end
+
+      it 'raises an exception when enabled' do
+        proxy_adapter.enabled = true
+        expect{ proxy_adapter.send :raise_or_pass_through, :method_name, :arg }.to raise_error
+      end
+
+      it 'does not raise an exception when disabled' do
+        proxy_adapter.enabled = false
+        adapter.stub(:method_name)
+        expect{ proxy_adapter.send :raise_or_pass_through, :method_name, :arg }.to_not raise_error
+      end
+    end
+
+    context 'when strategy is set to :warn' do
+      before :each do
+        proxy_adapter.strategy = :warn
+      end
+
+      it 'passes method call through to the adapter' do
+        proxy_adapter.should_receive(:pass_through).with(:method_name, :arg)
+        proxy_adapter.send :raise_or_pass_through, :method_name, :arg
+      end
+    end
+
+    context 'when strategy is set to :pass_through' do
+      before :each do
+        proxy_adapter.strategy = :pass_through
+      end
+
+      it 'passes method call through to the adapter' do
+        proxy_adapter.should_receive(:pass_through).with(:method_name, :arg)
+        proxy_adapter.send :raise_or_pass_through, :method_name, :arg
+      end
+    end
+  end
+
+  # Overridden methods -------------------------------------------------------
+
+  describe '#execute' do
+    it 'invokes #raise_or_pass_through' do
+      proxy_adapter.should_receive(:raise_or_pass_through).with(:execute, 'SELECT COUNT(*) FROM tables;', 'name')
+      proxy_adapter.execute('SELECT COUNT(*) FROM tables;', 'name')
+    end
+
+    it 'invokes #pass_through if SQL is BEGIN' do
+      proxy_adapter.should_receive(:pass_through).with(:execute, 'BEGIN', 'name')
+      proxy_adapter.execute('BEGIN', 'name')
+    end
+
+    it 'invokes #pass_through if SQL is ROLLBACK' do
+      proxy_adapter.should_receive(:pass_through).with(:execute, 'ROLLBACK', 'name')
+      proxy_adapter.execute('ROLLBACK', 'name')
+    end
+
+    it 'invokes #pass_through if SQL is SAVEPOINT' do
+      proxy_adapter.should_receive(:pass_through).with(:execute, 'SAVEPOINT', 'name')
+      proxy_adapter.execute('SAVEPOINT', 'name')
+    end
+  end
+
+  describe '#insert' do
+    it 'invokes #raise_or_pass_through' do
+      proxy_adapter.should_receive(:raise_or_pass_through).with(
+        :insert, 'SQL', 'name', 'pk', 'id_value', 'sequence_name', ['bind']
+      )
+      proxy_adapter.insert('SQL', 'name', 'pk', 'id_value', 'sequence_name', ['bind'])
+    end
+  end
+
+  describe '#update' do
+    it 'invokes #raise_or_pass_through' do
+      proxy_adapter.should_receive(:raise_or_pass_through).with(:update, 'SQL', 'name', [])
+      proxy_adapter.send(:update, 'SQL', 'name', [])
+    end
+  end
+
+  describe '#delete' do
+    it 'invokes #raise_or_pass_through' do
+      proxy_adapter.should_receive(:raise_or_pass_through).with(:delete, 'SQL', 'name', [])
+      proxy_adapter.send(:delete, 'SQL', 'name', [])
+    end
+  end
+
+  describe '#select_rows' do
+    it 'invokes #raise_or_pass_through' do
+      proxy_adapter.should_receive(:raise_or_pass_through).with(:select_rows, 'SQL', 'name')
+      proxy_adapter.select_rows('SQL', 'name')
+    end
+  end
+
+  describe '#select' do
+    it 'invokes #raise_or_pass_through' do
+      proxy_adapter.should_receive(:raise_or_pass_through).with(:select, 'SQL', 'name')
+      proxy_adapter.send(:select, 'SQL', 'name')
+    end
+  end
+
+  describe '#select_all' do
+    it 'invokes #raise_or_pass_through' do
+      proxy_adapter.should_receive(:raise_or_pass_through).with(:select_all, 'SQL', 'name', [])
+      proxy_adapter.send(:select_all, 'SQL', 'name', [])
+    end
+  end
+
+  describe '#select_one' do
+    it 'invokes #raise_or_pass_through' do
+      proxy_adapter.should_receive(:raise_or_pass_through).with(:select_one, 'SQL', 'name')
+      proxy_adapter.send(:select_one, 'SQL', 'name')
+    end
+  end
+
+  describe '#select_value' do
+    it 'invokes #raise_or_pass_through' do
+      proxy_adapter.should_receive(:raise_or_pass_through).with(:select_value, 'SQL', 'name')
+      proxy_adapter.send(:select_value, 'SQL', 'name')
+    end
+  end
+
+  describe '#select_values' do
+    it 'invokes #raise_or_pass_through' do
+      proxy_adapter.should_receive(:raise_or_pass_through).with(:select_values, 'SQL', 'name')
+      proxy_adapter.send(:select_values, 'SQL', 'name')
+    end
+  end
+
+  describe '#exec_query' do
+    it 'invokes #raise_or_pass_through' do
+      proxy_adapter.should_receive(:raise_or_pass_through).with(:exec_query, 'SQL', 'name', [])
+      proxy_adapter.send(:exec_query, 'SQL', 'name', [])
+    end
+  end
+
+  describe '#exec_insert' do
+    it 'invokes #raise_or_pass_through' do
+      proxy_adapter.should_receive(:raise_or_pass_through).with(:exec_insert, 'SQL', 'name', [])
+      proxy_adapter.send(:exec_insert, 'SQL', 'name', [])
+    end
+  end
+
+  describe '#exec_delete' do
+    it 'invokes #raise_or_pass_through' do
+      proxy_adapter.should_receive(:raise_or_pass_through).with(:exec_delete, 'SQL', 'name', [])
+      proxy_adapter.send(:exec_delete, 'SQL', 'name', [])
+    end
+  end
+
+  describe '#exec_update' do
+    it 'invokes #raise_or_pass_through' do
+      proxy_adapter.should_receive(:raise_or_pass_through).with(:exec_update, 'SQL', 'name', [])
+      proxy_adapter.send(:exec_update, 'SQL', 'name', [])
+    end
+  end
+
+  describe '#insert_sql' do
+    it 'invokes #raise_or_pass_through' do
+      proxy_adapter.should_receive(:raise_or_pass_through).with(:'insert_sql', 'SQL', 'name', 'pk', 'id_value', 'sequence_name', ['bind'])
+      proxy_adapter.send(:'insert_sql', 'SQL', 'name', 'pk', 'id_value', 'sequence_name', ['bind'])
+    end
+  end
+
+  describe '#delete_sql' do
+    it 'invokes #raise_or_pass_through' do
+      proxy_adapter.should_receive(:raise_or_pass_through).with(:'delete_sql', 'SQL', 'name')
+      proxy_adapter.send(:'delete_sql', 'SQL', 'name')
+    end
+  end
+
+  describe '#update_sql' do
+    it 'invokes #raise_or_pass_through' do
+      proxy_adapter.should_receive(:raise_or_pass_through).with(:'update_sql', 'SQL', 'name')
+      proxy_adapter.send(:'update_sql', 'SQL', 'name')
+    end
+  end
+
+  # --------------------------------------------------------------------------
+end

data/spec/rspec/dsl_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+require_relative '../../lib/nogo/rspec/dsl'
+
+describe NoGo::RSpec::DSL do
+  describe '::nogo_example_group' do
+    it 'returns an rspec example group' do
+      dummy_example_group = mock
+      block = Proc.new {}
+      RSpec::Core::ExampleGroup.stub(:subclass).and_return(dummy_example_group)
+      NoGo::RSpec::DSL.nogo_example_group(&block).should == dummy_example_group
+    end
+
+    context 'executed' do
+      it 'invokes nogo before all block' do
+        dummy = mock
+        dummy.should_receive(:execute)
+        block = Proc.new { dummy.execute }
+        NoGo::RSpec::DSL.stub(:NogoBeforeAllBlock).and_return(block)
+        NoGo::RSpec::DSL.nogo_example_group{ it{ :example_to_trigger_callbacks }}.run mock.as_null_object
+      end
+
+      it 'invokes nogo after all block' do
+        dummy = mock
+        dummy.should_receive(:execute)
+        block = Proc.new { dummy.execute }
+        NoGo::RSpec::DSL.stub(:NogoAfterAllBlock).and_return(block)
+        NoGo::RSpec::DSL.nogo_example_group{ it{ :example_to_trigger_callbacks}}.run mock.as_null_object
+      end
+
+      it 'invokes instance eval with example group block' do
+        dummy = mock
+        dummy.should_receive(:execute)
+        block = Proc.new { dummy.execute }
+        NoGo::RSpec::DSL.nogo_example_group(&block).run mock.as_null_object
+      end
+    end
+  end
+
+  describe 'NogoBeforeAllBlock' do
+    it 'invokes NoGo::Connection::push_enabled_state' do
+      NoGo::Connection.should_receive(:push_enabled_state)
+      NoGo::Connection.stub(:enabled=)
+      NoGo::RSpec::DSL::NogoBeforeAllBlock.call
+    end
+
+    it 'enables proxy adapter' do
+      NoGo::Connection.stub(:push_enabled_state)
+      NoGo::Connection.should_receive(:enabled=).with(true)
+      NoGo::RSpec::DSL::NogoBeforeAllBlock.call
+    end
+  end
+
+  describe 'NogoAfterAllBlock' do
+    it 'invokes NoGo::Connection::pop_enabled_state' do
+      NoGo::Connection.should_receive(:pop_enabled_state)
+      NoGo::RSpec::DSL::NogoAfterAllBlock.call
+    end
+  end
+end
+
+describe 'nogo' do
+  it 'registers a nogo example group' do
+    dummy_example_group = mock
+    dummy_example_group.should_receive(:register)
+    NoGo::RSpec::DSL.stub(:nogo_example_group).and_return(dummy_example_group)
+    nogo{}
+  end
+end
+
+describe 'database_restricted' do
+  it 'registers a nogo example group' do
+    dummy_example_group = mock
+    dummy_example_group.should_receive(:register)
+    NoGo::RSpec::DSL.stub(:nogo_example_group).and_return(dummy_example_group)
+    database_restricted{}
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'active_record'
+require 'rspec'
+
+require_relative '../lib/nogo'

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: nogo
+version: !ruby/object:Gem::Version
+  version: 1.0.0.beta
+  prerelease: 6
+platform: ruby
+authors:
+- Andy Ogzewalla
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-05 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70138985281760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70138985281760
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &70138985281220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70138985281220
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70138985280720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.7.0
+  type: :development
+  prerelease: false
+  version_requirements: *70138985280720
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &70138985280140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: *70138985280140
+description: A library that lets you know when your code touches your database
+email:
+- andyogzewalla@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- lib/active_record/connection_adapters/nogo_adapter.rb
+- lib/active_record/import.rb
+- lib/nogo.rb
+- lib/nogo/abstract_method_overrides.rb
+- lib/nogo/connection.rb
+- lib/nogo/proxy_adapter.rb
+- lib/nogo/rspec.rb
+- lib/nogo/rspec/dsl.rb
+- lib/nogo/version.rb
+- nogo.gemspec
+- spec/active_record/connection_adapters/nogo_adapter_spec.rb
+- spec/nogo/connection_spec.rb
+- spec/nogo/proxy_adapter_spec.rb
+- spec/rspec/dsl_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: A library that lets you know when your code touches your database
+test_files:
+- spec/active_record/connection_adapters/nogo_adapter_spec.rb
+- spec/nogo/connection_spec.rb
+- spec/nogo/proxy_adapter_spec.rb
+- spec/rspec/dsl_spec.rb
+- spec/spec_helper.rb