capybarbecue 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8fa420c19a4cf57eb1a6fb4d9122e1a01f7355cf
+  data.tar.gz: f3456b9851b38b602da77a2a542bfb78d71cf602
+SHA512:
+  metadata.gz: c50a76bc67c480cddab96a0aa8a55459b6522ec022e6961ae369d7dc7c14953394b08c37b9501be7fc34437b44da186a6b1efc72f725014e7da1ab4db5fd065a
+  data.tar.gz: 329541d5aabcf0be4d796721aca4156fc52971d64c94f6b6113a0cf4cf09dbd463dc12c482487c18020e865f18773e89f2d38b9e22c556e088d8fd7a4ae14371

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,15 @@
+source "http://rubygems.org"
+
+group :development do
+  gem "rspec"
+  gem "rr", require: false
+  gem "yard"
+  gem "rdoc"
+  gem "bundler"
+  gem "jeweler"
+  gem "poltergeist"
+  gem "launchy"
+end
+
+gem "activesupport"
+gem "capybara", "~>2.1.0"

data/Gemfile.lock

@@ -0,0 +1,78 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (4.0.0)
+      i18n (~> 0.6, >= 0.6.4)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    addressable (2.3.5)
+    atomic (1.1.10)
+    capybara (2.1.0)
+      mime-types (>= 1.16)
+      nokogiri (>= 1.3.3)
+      rack (>= 1.0.0)
+      rack-test (>= 0.5.4)
+      xpath (~> 2.0)
+    diff-lcs (1.2.4)
+    eventmachine (1.0.3)
+    faye-websocket (0.4.7)
+      eventmachine (>= 0.12.0)
+    git (1.2.5)
+    http_parser.rb (0.5.3)
+    i18n (0.6.4)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.8.0)
+    launchy (2.3.0)
+      addressable (~> 2.3)
+    mime-types (1.23)
+    mini_portile (0.5.1)
+    minitest (4.7.5)
+    multi_json (1.7.7)
+    nokogiri (1.6.0)
+      mini_portile (~> 0.5.0)
+    poltergeist (1.3.0)
+      capybara (~> 2.1.0)
+      faye-websocket (>= 0.4.4, < 0.5.0)
+      http_parser.rb (~> 0.5.3)
+    rack (1.5.2)
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rake (10.1.0)
+    rdoc (4.0.1)
+      json (~> 1.4)
+    rr (1.1.1)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.4)
+    rspec-expectations (2.14.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.2)
+    thread_safe (0.1.2)
+      atomic
+    tzinfo (0.3.37)
+    xpath (2.0.0)
+      nokogiri (~> 1.3)
+    yard (0.8.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport
+  bundler
+  capybara (~> 2.1.0)
+  jeweler
+  launchy
+  poltergeist
+  rdoc
+  rr
+  rspec
+  yard

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Andrew DiMichele
+
+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/NOTES.txt

@@ -0,0 +1,37 @@
+= Rails Thread =
+Put a proxy class in front of Capybara::Driver::Base and Capybara::Driver::Node
+  Capybara:Session#driver is the instance of driver
+  Probably need to create a new driver which is a proxy for another driver
+Proxy class puts method_missing args on MQ to be sent to Driver thread
+Needs to yield to Driver thread and then execute the RackRunner
+RackRunner reads rack requests from a MQ, calling the rack endpoint with those; returns when done
+  This should probably use the rack-test gem? This probably isn't what we want since this simulates a browser
+
+= Driver Thread =
+Reads RPCs off a MQ, calls the commands in the appropriate class, and puts the response on another MQ
+Part of the new driver passed to Capybara
+Should be able to use the Capybara driver of your choice
+How is a Node passed back to the Rails thread? Maybe it's OK for Node queries to go straight through to the webdriver?
+  These could trigger web requests (like a click) that would not be processed... maybe wrap in the Barbecue driver
+  so that the RackRunner is triggered appropriately? That still causes a problem when clicking a link since the
+  webdriver might block... need to think about this some more
+
+= Capybara::Server =
+Rewrite this class entirely
+Should spawn a simple Rack webserver that just take the #call Args and puts them on the MQ
+Needs to block until MQ response is received
+Webserver could be Puma or EventMachine
+
+
+Notes:
+Queue class provided by 'thread' library
+
+----- Latest Notes -----
+* Interface with Session instead
+* Don't try to mimic interfaces - just ferry calls over
+* Add field to the base node class so we can tell it's a node
+* If return value is a Node then wrap it
+* If return value is enumerable, wrap its Node values via #map
+
+---- TODO ----
+* Raise errors during timeouts if Time is frozen

data/README.rdoc

@@ -0,0 +1,19 @@
+= capybarbecue
+
+Description goes here.
+
+== Contributing to capybarbecue
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2013 Andrew DiMichele. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+require './lib/capybarbecue/version'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "capybarbecue"
+  gem.homepage = "http://github.com/adimichele/capybarbecue"
+  gem.license = "MIT"
+  gem.summary = %Q{Makes your Capybara test suite work better}
+  gem.description = %Q{Makes fundamental changes to Capybara's threading architecture so you can write stable tests with a shared database connection.}
+  gem.email = "backflip@gmail.com"
+  gem.authors = ["Andrew DiMichele"]
+  gem.version = Capybarbecue::VERSION
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/lib/capybarbecue.rb

@@ -0,0 +1,44 @@
+require 'active_support/all'
+
+module Capybarbecue
+  class << self
+    def activated?
+      Capybara.respond_to? :original_session
+    end
+
+    def activate!
+      return if activated?
+      require 'capybarbecue/async_call'
+      require 'capybarbecue/async_delegate_class'
+      require 'capybarbecue/rack_runner'
+      require 'capybarbecue/server'
+
+      (class << Capybara; self end).instance_eval do
+        alias_method :original_session, :current_session
+        define_method :current_session do
+          Capybarbecue::AsyncDelegateClass.new(original_session) do
+            Capybara.app.handle_requests
+          end
+        end
+      end
+
+      Capybara.send(:session_pool).clear
+
+      # Swap out Capybara's server for the one that waits
+      # Do this by deleting everything in Capybara#session_pool (private) and swapping Capybara.app
+      new_app = Capybarbecue::Server.new(Capybara.app)
+      Capybara.app = new_app
+    end
+
+    def deactivate!
+      # Make sure this kills all threads too?
+      return unless activated?
+      (class << Capybara; self end).instance_eval do
+        alias_method :current_session, :original_session
+        remove_method :original_session
+      end
+      Capybara.send(:session_pool).clear
+      Capybara.app = Capybara.app.app
+    end
+  end
+end

data/lib/capybarbecue/async_call.rb

@@ -0,0 +1,63 @@
+require 'thread'
+
+class AsyncCall # Asynchronously calls a method
+  DEFAULT_TIMEOUT = 5.0
+  attr_reader :thread
+  attr_reader :ready
+  attr_reader :to_s
+  alias :ready? :ready
+
+  def initialize(obj, method, *args, &block)
+    @obj, @method, @args, @block = obj, method, args, block
+    @ready = false
+    @response = nil
+    @exception = nil
+    @thread = Thread.new do
+      begin
+        respond_with obj.send(method, *args, &block)
+      rescue Exception => e
+        respond_with_exception e
+      end
+    end
+  end
+
+  # If a block is passed, it will be called repeatedly until a response comes in
+  def wait_for_response(timeout=DEFAULT_TIMEOUT)
+    started_at = Time.now
+    while Time.now - started_at < timeout.seconds && !ready?
+      yield if block_given?
+      # It feels dangerous not to sleep here... keep a pulse on this (sleep causes performance problems)
+      Thread.pass
+    end
+    kill! and raise Timeout::Error.new('Timeout expired before response received') unless ready?
+    if @exception.present?
+      # Add the backtrace from this thread to make it useful
+      backtrace = @exception.backtrace + Kernel.caller
+      @exception.set_backtrace(backtrace)
+      raise @exception
+    end
+    @response
+  end
+
+  def kill!
+    @thread.kill
+  end
+
+  def to_s
+    s = "#{@obj.class.name}##{@method}(#{@args.map{ |a| a.class.name }.join(', ')})"
+    s += ' { ... }' if @block.present?
+    s
+  end
+
+  private
+
+  def respond_with(value)
+    @response = value
+    @ready = true
+  end
+
+  def respond_with_exception(e)
+    @exception = e
+    @ready = true
+  end
+end

data/lib/capybarbecue/async_delegate_class.rb

@@ -0,0 +1,30 @@
+module Capybarbecue
+  class AsyncDelegateClass
+    attr_reader :instance
+
+    def initialize(instance, &wait_proc)
+      @instance = instance
+      @wait_proc = wait_proc # Called repeatedly while waiting
+    end
+
+    def method_missing(method, *args, &block)
+      call = AsyncCall.new(@instance, method, *args, &block)
+      wrap_response(call.wait_for_response(&@wait_proc))
+    end
+
+    private
+
+    def respond_to_missing?(method, include_all=false)
+      @instance.respond_to?(method, include_all)
+    end
+
+    # Wrap anything that looks like Capybara
+    def wrap_response(value)
+      if value.class.name.include?('Capybara')
+        AsyncDelegateClass.new(value, &@wait_proc)
+      else
+        value
+      end
+    end
+  end
+end

data/lib/capybarbecue/rack_runner.rb

@@ -0,0 +1,7 @@
+module Capybarbecue
+  class RackRunner
+    # Rack runner portion of main thread
+    # Reads rack requests of a message queue, runs them, and puts the result on another MQ
+    # Should have some sort of delay or signaling system to eliminate race conditions when waiting for requests
+  end
+end

data/lib/capybarbecue/server.rb

@@ -0,0 +1,64 @@
+require 'thread'
+
+module Capybarbecue
+  class Server
+    DEFAULT_TIMEOUT = 30
+    attr_accessor :wait_for_response # For testing - set to false to keep #call from blocking
+    attr_accessor :timeout, :app
+
+    def initialize(app)
+      @app = app
+      @requestmq = Queue.new
+      @wait_for_response = true
+      @timeout = DEFAULT_TIMEOUT
+    end
+
+    def call(env)
+      queue_and_wait(env)
+    end
+
+    # Should be run by another thread - respond to all queued requests
+    def handle_requests
+      until @requestmq.empty?
+        request = @requestmq.deq(true)
+        begin
+          request.response = @app.call(request.env)
+        rescue Exception => e
+          request.exception = e
+        end
+      end
+    end
+
+    private
+
+    def queue_and_wait(env)
+      request = QueuedRequest.new(env)
+      @requestmq.enq(request)
+      return unless wait_for_response
+      started_at = Time.now
+      while !request.ready? && Time.now - started_at < timeout.seconds
+        # It feels dangerous not to sleep here... keep a pulse on this (sleep causes performance problems)
+        Thread.pass
+      end
+      raise Timeout::Error.new('Timeout expired before response received') unless request.ready?
+      if request.exception.present?
+        # Add the backtrace from this thread to make it useful
+        backtrace = request.exception.backtrace + Kernel.caller
+        request.exception.set_backtrace(backtrace)
+        raise request.exception
+      end
+      request.response
+    end
+
+    class QueuedRequest
+      attr_reader :env
+      attr_accessor :response, :exception
+      def initialize(env)
+        @env = env
+      end
+      def ready?
+        @response.present? || @exception.present?
+      end
+    end
+  end
+end

data/lib/capybarbecue/version.rb

@@ -0,0 +1,3 @@
+module Capybarbecue
+  VERSION = '0.1.0'
+end

data/spec/capybarbecue/async_call_spec.rb

@@ -0,0 +1,94 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe AsyncCall do
+  let(:obj) { Object.new }
+  let(:method) { :nil? }
+  let(:args) { [] }
+  let(:block) { nil }
+  subject{ AsyncCall.new(obj, method, *args, &block) }
+  after{ subject.kill! }
+  describe '#thread' do
+    it 'should be a thread' do
+      expect(subject.thread).to be_a Thread
+    end
+  end
+  describe '#ready' do
+    let(:method){ :test }
+    before do
+      stub(obj).test do
+        sleep 0.1
+      end
+    end
+    it 'should be true once the response is ready' do
+      expect(subject).to_not be_ready
+      sleep 0.11
+      expect(subject).to be_ready
+    end
+  end
+  describe '#wait_for_response' do
+    let(:obj){ Object }
+    let(:method){ :name }
+    it 'returns the value' do
+      expect(subject.wait_for_response).to eq 'Object'
+    end
+    context 'with a block' do
+      before do
+        stub(obj).name { sleep 0.3 }
+      end
+      it 'calls the block repeatedly while waiting' do
+        mock(obj).foo.at_least(2)
+        subject.wait_for_response { obj.foo }
+      end
+    end
+    context 'when the timeout expires' do
+      let(:method){ :test }
+      before do
+        stub(obj).test do
+          sleep 1
+        end
+      end
+      it 'raises an error and kills the thread' do
+        expect{ subject.wait_for_response(0.01) }.to raise_error Timeout::Error
+        sleep 0.1
+        expect(subject.thread).to_not be_alive
+      end
+    end
+    context 'when the call raises an exception' do
+      let(:method){ :test }
+      before do
+        stub(obj).test do
+          1 / 0
+        end
+      end
+      it 'also raises the exception' do
+        expect{ subject.wait_for_response }.to raise_error ZeroDivisionError
+      end
+    end
+  end
+  describe '#kill!' do
+    let(:method){ :test }
+    before do
+      stub(obj).test do
+        sleep 1
+      end
+    end
+    it 'kills the thread' do
+      expect{ subject.kill!; sleep 0.01 }.to change{ subject.thread.stop? }.from(false).to(true)
+    end
+  end
+  describe '#to_s' do
+    let(:obj) { Object.new }
+    let(:method) { :foo }
+    let(:args) { [1, Object.new] }
+    before{ stub(obj).foo.with_any_args }
+    it 'returns the method as a string' do
+      expect(subject.to_s).to eq 'Object#foo(Fixnum, Object)'
+    end
+    context 'with a block' do
+      let(:block){ Proc.new do end }
+      it 'returns the method as a string and indicates a block' do
+        expect(subject.to_s).to eq 'Object#foo(Fixnum, Object) { ... }'
+      end
+    end
+  end
+end

data/spec/capybarbecue/async_delegate_class_spec.rb

@@ -0,0 +1,64 @@
+require File.expand_path(File.dirname(__FILE__) + '../../spec_helper')
+
+describe Capybarbecue::AsyncDelegateClass do
+  let(:obj){ Object.new }
+  subject{ Capybarbecue::AsyncDelegateClass.new(obj) }
+
+  it 'calls the method on the session asynchronously' do
+    mock(obj).foo{ 'cats' }
+    expect(subject.foo).to eq 'cats'
+  end
+
+  context 'when the object returned is not a Capybara object' do
+    before{ mock(obj).foo{ 'cats' } }
+    it 'should be itself' do
+      expect(subject.foo).to be_an_instance_of String
+    end
+  end
+
+  context 'when the object returned is a Capybara object' do
+    before { mock(obj).foo{ Capybara::Driver::Base.new } }
+    it 'wraps the return value in AsyncDelegateClass' do
+      expect(subject.foo).to be_an_instance_of Capybarbecue::AsyncDelegateClass
+    end
+    context 'when a block is given' do
+      subject do
+        Capybarbecue::AsyncDelegateClass.new(obj) do
+          obj.wait_func
+        end
+      end
+      it 'preserves the wait_proc' do
+        mock(obj).wait_func.twice
+        resp = subject.foo
+        stub(resp.instance).foo
+        resp.foo
+      end
+    end
+  end
+
+  describe '#instance' do
+    it 'should be the instance' do
+      subject.instance.should be obj
+    end
+  end
+
+  describe '#respond_to?' do
+    it 'returns @instance#respond_to?' do
+      stub(obj).foo
+      expect(subject).to respond_to :foo
+    end
+  end
+
+  context 'when a block is given' do
+    subject do
+      Capybarbecue::AsyncDelegateClass.new(obj) do
+        obj.wait_func
+      end
+    end
+    it 'runs the block before returning' do
+      mock(obj).wait_func.at_least(2)
+      stub(obj).foo { sleep 0.3 }
+      subject.foo
+    end
+  end
+end

data/spec/capybarbecue/rack_runner_spec.rb

@@ -0,0 +1,4 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Capybarbecue::RackRunner do
+end

data/spec/capybarbecue/server_spec.rb

@@ -0,0 +1,55 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Capybarbecue::Server do
+  let(:app) { Object.new }
+  subject{ Capybarbecue::Server.new(app) }
+  before{ subject.timeout = 5 }  # This makes tests fail a little quicker
+  describe '#app' do
+    its(:app){ should be app }
+  end
+  describe '#handle_requests' do
+    before{ subject.wait_for_response = false }
+    it 'responds to all queued requests' do
+      request1 = Object.new
+      request2 = Object.new
+      mock(app).call(request1)
+      mock(app).call(request2)
+      subject.call(request1)
+      subject.call(request2)
+      subject.handle_requests
+    end
+  end
+  describe '#call' do
+    context 'when another thread handles the request' do
+      before do
+        stub(app).call.with_any_args { |arg| arg }
+      end
+      let!(:thread) do
+        @thread = Thread.new do
+          while true
+            subject.handle_requests
+            sleep 0.05
+          end
+        end
+      end
+      after { thread.kill }
+      it 'gives the response' do
+        expect(subject.call('avacado')).to eq 'avacado'
+      end
+      context 'when there is an exception' do
+        before do
+          stub(app).call.with_any_args { raise Exception.new }
+        end
+        it 'raises the exception' do
+          expect{ subject.call('avacado') }.to raise_error
+        end
+      end
+    end
+    context 'when the timeout expires' do
+      before{ subject.timeout = 0.01 }
+      it 'raises an exception' do
+        expect{ subject.call(nil) }.to raise_error Timeout::Error
+      end
+    end
+  end
+end

data/spec/capybarbecue_spec.rb

@@ -0,0 +1,69 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Capybarbecue do
+  describe '#activated' do
+    subject{ Capybarbecue.activated? }
+    it 'is true because spec_helper activates it' do
+      expect(subject).to be_true
+    end
+    context 'when deactivated' do
+      before{ Capybarbecue.deactivate! }
+      it 'is false' do
+        expect(subject).to be_false
+      end
+    end
+  end
+  describe '#activate' do
+    before do
+      Capybarbecue.deactivate!
+    end
+    subject{ Capybarbecue.activate! }
+    after{ Capybarbecue.deactivate! }
+    it 'redefines Capybara#current_session' do
+      subject
+      expect(Capybara.current_session).to be_an_instance_of Capybarbecue::AsyncDelegateClass
+      expect(Capybara.current_session.instance).to be Capybara.original_session
+    end
+    it 'saves old Capybara#current_session Capybara#original_session' do
+      subject
+      expect(Capybara.original_session).to be_an_instance_of Capybara::Session
+    end
+    it 'clears the session pool' do
+      Capybara.current_session
+      Capybara.send(:session_pool).should_not be_empty
+      subject
+      Capybara.send(:session_pool).should be_empty
+    end
+    it 'inserts Capybarbecue::Server as the app' do
+      old_app = Capybara.app
+      subject
+      expect(Capybara.app).to be_an_instance_of Capybarbecue::Server
+      expect(Capybara.app.app).to be old_app
+    end
+  end
+  
+  describe '#deactivate' do
+    before { Capybarbecue.activate! }
+    subject { Capybarbecue.deactivate! }
+    after { Capybarbecue.activate! }
+    it 'restores #current_session' do
+      subject
+      expect(Capybarbecue).to_not be_activated
+      expect(Capybara.current_session).to be_an_instance_of Capybara::Session
+    end
+    it 'deletes #original_session' do
+      subject
+      expect(Capybara.methods).to_not include :original_session
+    end
+    it 'restores the server app' do
+      subject
+      expect(Capybara.app).to_not be_an_instance_of Capybarbecue::Server
+    end
+    it 'clears the session pool' do
+      Capybara.current_session
+      Capybara.send(:session_pool).should_not be_empty
+      subject
+      Capybara.send(:session_pool).should be_empty
+    end
+  end
+end

data/spec/integration/element_spec.rb

@@ -0,0 +1,91 @@
+require File.expand_path(File.dirname(__FILE__) + '../../spec_helper')
+
+describe 'With a real life app', :type => :feature, :capybara_feature => true do
+  # Test that operations on nodes work as expected
+  let(:path){ '/test/path'}
+  before{ visit path }
+  describe Capybara::Node::Element do
+    subject{ find("##{id}") }
+    describe '#text' do
+      let(:id){ 'hidden_text' }
+      its(:text){ should include 'I am text' }
+    end
+    describe '#[]' do
+      let(:id){ 'hidden_text' }
+      its(['id']){ should eq id }
+    end
+    describe '#value' do
+      let(:id){ 'volvo' }
+      its(:value){ should eq 'volvo' }
+    end
+    describe '#set' do
+      let(:id){ 'text_field' }
+      it 'sets the value of the field' do
+        expect{ subject.set 'peanuts' }.to change{ subject.value }.to 'peanuts'
+      end
+    end
+    describe '#select_option, #unselect_option, #selected?, #checked?' do
+      let(:id){ 'volvo' }
+      it 'selects and unselects an option' do
+        expect{ subject.select_option }.to change{ subject.selected? }.from(false).to(true)
+        expect{ subject.unselect_option }.to change{ subject.selected? }.from(true).to(false)
+        expect(subject).to_not be_checked
+      end
+    end
+    describe '#click' do
+      let(:id){ 'link1' }
+      it 'follows the link' do
+        expect{ subject.click }.to change{ page.current_path }.to '/link/1'
+      end
+    end
+    describe '#hover' do
+      let(:id){ 'div1' }
+      before do
+        page.execute_script("document.getElementById('#{id}').onmouseover = function(){ document.write('hovered') }")
+      end
+      it 'triggers the hover js' do
+        subject.hover
+        page.should have_text 'hovered'
+      end
+    end
+    describe '#tag_name' do
+      let(:id){ 'div1' }
+      its(:tag_name){ should eq 'div' }
+    end
+    describe '#visible?' do
+      let(:id){ 'div1' }
+      it{ should be_visible }
+    end
+    describe '#disabled?' do
+      let(:id){ 'disabled_text' }
+      it{ should be_disabled }
+    end
+    describe '#path' do
+      let(:id){ 'text_field' }
+      pending 'is not supported in some drivers'
+    end
+    describe '#trigger' do
+      let(:id){ 'div1' }
+      before do
+        page.execute_script("document.getElementById('#{id}').onclick = function(){ document.write('sandwiches') }")
+      end
+      it 'triggers a click event' do
+        subject.trigger 'click'
+        expect(page).to have_text 'sandwiches'
+      end
+    end
+    describe '#drag_to' do
+      let(:id){ 'text_field' }
+      let(:target){ find('#disabled_text') }
+      it 'works?' do
+        subject.drag_to target
+      end
+    end
+    describe '#reload' do
+      let(:id){ 'text_field' }
+      it 'reloads the node' do
+        expect(subject.reload.value).to eq 'monkeys'
+      end
+    end
+  end
+end

data/spec/integration/session_spec.rb

@@ -0,0 +1,133 @@
+require File.expand_path(File.dirname(__FILE__) + '../../spec_helper')
+require 'fileutils'
+
+# Ideally want to test everything in Capybara::Session::DSL_METHODS
+# These methods haven't been tested yet:
+#NODE_METHODS = [
+#    :resolve, :query # These don't appear to be actual methods?
+#]
+#SESSION_METHODS = [
+#]
+#
+# As methods are tested, add them to this list... it will help keep track of test coverage as Capybara changes
+#NODE_METHODS = [
+#    :find, :all, :first, :find_by_id, :find_button, :find_link, :find_field, :has_css?, :has_no_css?, :has_link?, :text,
+#    :has_no_link?, :has_button?, :has_no_button?, :has_field?, :has_no_field?, :has_xpath?, :has_no_xpath?,
+#    :has_checked_field?, :has_unchecked_field?, :has_selector?, :has_no_selector?, :assert_selector, :assert_no_selector,
+#    :has_no_checked_field?, :has_no_unchecked_field?, :has_select?, :has_no_select?, :has_no_table?, :has_table?,
+#    :has_content?, :has_text?, :has_no_content?, :has_no_text?, :field_labeled,
+#    :click_link_or_button, :click_button, :click_link, :click_on, :fill_in, :choose, :check, :uncheck, :select, :unselect, :attach_file
+#]
+#SESSION_METHODS = [
+#    :current_url, :current_host, :current_path, :visit, :body, :html, :source,
+#    :title, :has_title?, :has_no_title?, :status_code, :response_headers,
+#    :reset_session!, :current_scope, :save_page, :save_and_open_page, :save_screenshot,
+#    :within, :within_fieldset, :within_table, :within_frame, :within_window,
+#    :evaluate_script, :execute_script
+#]
+# Notes: current_scope is used extensively within Capybara
+
+describe 'With a real life app', :type => :feature, :capybara_feature => true do
+  let(:path){ '/test/path'}
+  before{ visit path }
+  scenario 'page properties all work' do
+    expect(title).to eq 'Test Rack App'
+    expect(page).to have_title 'Test Rack App'
+    expect(page).to have_no_title 'Test Crack App'
+    expect(current_url).to end_with '/test/path'
+    expect(current_host).to include '127.0.0.1'
+    expect(current_path).to eq '/test/path'
+    expect(status_code).to eq 200
+    expect(response_headers['Content-Type']).to eq 'text/html'
+  end
+  context 'with a temp dir' do
+    let(:path){ './tmp/test' }
+    before{ FileUtils.mkdir_p path }
+    after{ FileUtils.rm_rf path }
+    scenario 'we can save page screenshots and pages' do
+      save_page File.join(path, 'save.html')
+      save_and_open_page File.join(path, 'save_and_open.html')
+      save_screenshot File.join(path, 'screenshot.png')
+    end
+  end
+  scenario 'we can check page content' do
+    expect(page).to have_content '/test/path'
+    expect(page).to have_no_content '/another/path'
+    expect(page).to have_text '/test/path'
+    expect(page).to have_no_text '/another/path'
+    expect(body).to include '/test/path'
+    expect(html).to include '/test/path'
+    expect(source).to include '/test/path'
+    expect(text).to include '/test/path'
+  end
+  scenario 'we can find elements on the page' do
+    expect(all('div')).to be_present
+    expect(first('div')).to be_present
+    expect(find('#div1')).to be_present
+    expect(find_by_id('div1')).to be_present
+    expect(find_button('Imma button!')).to be_present
+    expect(find_link('click1')).to be_present
+    expect(find_field('text_field')).to be_present
+  end
+  scenario 'we can check for elements on the page' do
+    expect(page).to have_selector('div#div1')
+    expect(page).to have_no_selector('a#div1')
+    page.assert_selector 'div#div1'
+    page.assert_no_selector 'a#div1'
+    expect(page).to have_xpath('//div/div/a')
+    expect(page).to have_no_xpath('//div/oops/a')
+    expect(page).to have_css('div#div1')
+    expect(page).to have_no_css('a#div1')
+    expect(page).to have_link('click1')
+    expect(page).to have_no_link('dontclick1')
+    expect(page).to have_button('Imma button!')
+    expect(page).to have_no_button('I aint no button')
+    expect(page).to have_field('text_field')
+    expect(page).to have_no_field('no_text_field')
+    expect(page).to have_checked_field('checkbox_field2')
+    expect(page).to have_no_checked_field('checkbox_field')
+    expect(page).to have_unchecked_field('checkbox_field')
+    expect(page).to have_no_unchecked_field('checkbox_field2')
+    expect(page).to have_select('select_field')
+    expect(page).to have_no_select('nota_select_field')
+    expect(page).to have_table('table1')
+    expect(page).to have_no_table('div1')
+  end
+  scenario 'we can interact with an element on the page' do
+    expect{ click_link_or_button 'link2' }.to change{ current_path }.to '/link/2'
+    expect{ click_on 'link1' }.to change{ current_path }.to '/link/1'
+    expect{ click_link 'link2' }.to change{ current_path }.to '/link/2'
+    expect{ click_button 'button1' }.to change{ current_path }.to '/button/1'
+    expect{ fill_in 'text_field', with: 'red sox' }.to change{ find_field('text_field').value }.to 'red sox'
+    expect{ choose 'male' }.to change{ find_field('male').checked? }.to true
+    expect{ check 'checkbox_field' }.to change{ find_field('checkbox_field').checked? }.to true
+    expect{ uncheck 'checkbox_field' }.to change{ find_field('checkbox_field').checked? }.to false
+    expect{ page.select 'Volvo', from: 'select_field' }.to change{ find('#select_field').value }.to %w{volvo}
+    expect{ unselect 'Volvo', from: 'select_field' }.to change{ find('#select_field').value }.to []
+    attach_file 'file_field', File.expand_path(File.dirname(__FILE__) + '../../spec_helper.rb')
+    expect(find('#file_field').value).to end_with 'spec_helper.rb'
+  end
+  scenario 'we can search within elements' do
+    within 'div#div1' do
+      expect(page).to have_css 'div.divclass2'
+    end
+    within_fieldset 'fieldset1' do
+      expect(page).to have_field 'file_field'
+    end
+    within_table 'table1' do
+      expect(page).to have_content 'cell 1,1'
+    end
+    within_frame 'myframe' do
+      expect(page).to have_css '#inframe'
+    end
+    page.execute_script("window.open(null,'window1').document.write('i am an open window')") # create a window
+    within_window 'window1' do
+      expect(page.html).to have_content 'i am an open window'
+    end
+  end
+  scenario 'we can execute javascript' do
+    page.execute_script("document.write('it worked')")
+    expect(html).to match /it worked/
+    expect(evaluate_script('4 + 4')).to eq 8
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+#$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+#$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'capybara/rspec'
+require 'capybara/poltergeist'
+require 'capybarbecue'
+require 'rr'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+Capybara.default_driver = :poltergeist
+Capybara.app = TestRackApp.new
+Capybarbecue.activate!
+
+RSpec.configure do |config|
+  config.mock_with :rr
+end

data/spec/support/test_rack_app.rb

@@ -0,0 +1,64 @@
+require 'rack'
+
+class TestRackApp
+  def get_html(request)
+    <<-HTML % request.path
+    <html>
+      <head><title>Test Rack App</title></head>
+      <body>
+        <h1>%s</h1>
+        <div class='divclass1' id='div1'>
+          <div class='divclass2' id='div2'>
+            <a href='/link/1' id='link1'>click1</a>
+          </div>
+        </div>
+        <div class='divclass1' id='div3'>
+          <div class='divclass2' id='div4'>
+            <a href='/link/2' id='link2'>click2</a>
+          </div>
+        </div>
+        <div id='hidden_text'>I am <span id='hidden_portion' style='display:none;'>hidden </span>text</div>
+        <form id='testform'>
+          <input type='text' name='text_field' id='text_field' value='monkeys'></input>
+          <input type='text' name='disabled_text' id='disabled_text' disabled='1'></input>
+          <select name='select_field' id='select_field' multiple='1'>
+            <option value="volvo" id='volvo'>Volvo</option>
+            <option value="saab" id='saab'>Saab</option>
+            <option value="mercedes" id='mercedes'>Mercedes</option>
+            <option value="audi" id='audi'>Audi</option>
+          </select>
+          <fieldset id='fieldset1'>
+            <input type='checkbox' id='checkbox_field' name='checkbox_field' value='raisins'></input>
+            <input type='checkbox' id='checkbox_field2' name='checkbox_field2' value='peanuts' checked='1'></input>
+            <input type='radio' id='male' name='sex' value='male'>Male</input>
+            <input type='radio' id='female' name='sex' value='female'>Female</input>
+            <input type='file' id='file_field' name='file_field'></input>
+          </fieldset>
+          <button type="button" name='button1' id='button1' onclick='window.location="/button/1"'>Imma button!</button>
+        </form>
+        <table id='table1'>
+          <tr>
+            <td>cell 1,1</td>
+            <td>cell 1,2</td>
+          </tr>
+          <tr>
+            <td>cell 2,1</td>
+            <td>cell 2,2</td>
+          </tr>
+        </table>
+        <iframe id='myframe' name='myframe' src='/iframe'>
+        </iframe>
+      </body>
+    </html>
+    HTML
+  end
+
+  def call(env)
+    request = Rack::Request.new(env)
+    if request.path == '/iframe'
+      [200, {"Content-Type" => "text/html"}, ["<html><body><div id='inframe'></div></body></html>"]]
+    else
+      [200, {"Content-Type" => "text/html"}, [get_html(request)]]
+    end
+  end
+end

metadata

@@ -0,0 +1,210 @@
+--- !ruby/object:Gem::Specification
+name: capybarbecue
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrew DiMichele
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: capybara
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: rr
+  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: yard
+  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: rdoc
+  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: bundler
+  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: jeweler
+  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: poltergeist
+  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: launchy
+  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: Makes fundamental changes to Capybara's threading architecture so you
+  can write stable tests with a shared database connection.
+email: backflip@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- NOTES.txt
+- README.rdoc
+- Rakefile
+- lib/capybarbecue.rb
+- lib/capybarbecue/async_call.rb
+- lib/capybarbecue/async_delegate_class.rb
+- lib/capybarbecue/rack_runner.rb
+- lib/capybarbecue/server.rb
+- lib/capybarbecue/version.rb
+- spec/capybarbecue/async_call_spec.rb
+- spec/capybarbecue/async_delegate_class_spec.rb
+- spec/capybarbecue/rack_runner_spec.rb
+- spec/capybarbecue/server_spec.rb
+- spec/capybarbecue_spec.rb
+- spec/integration/element_spec.rb
+- spec/integration/session_spec.rb
+- spec/spec_helper.rb
+- spec/support/test_rack_app.rb
+homepage: http://github.com/adimichele/capybarbecue
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Makes your Capybara test suite work better
+test_files: []
+has_rdoc: