caius-culerity 0.1.5

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Alexander Lang
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,101 @@
+h2. Introduction
+
+Culerity integrates Cucumber and Celerity in order to test your application's full stack.
+
+Culerity lets you:
+* run Celerity from within Cucumber which allows you to test the full stack of your Rails (or other web) application from Database to in browser JavaScript
+* run your application in any Ruby (like MRI 1.8.6) while Celerity runs in JRuby so you can still use gems/plugins that would not work with JRuby
+* reuse existing Webrat-Style step definitions
+
+h2. Getting Started
+
+The following guide is written for a Rails application (tested with 2.2.2) but Culerity should work with any other Web Framework that is supported by Cucumber.
+
+First download JRuby and unpack it to some location, for example $HOME/jruby. Make sure that the jruby executable is in your path. You can do this by either setting your PATH accordingly...
+
+<pre><code> export PATH=$HOME/jruby/bin:$PATH</code></pre>
+ 
+... or by creating a symlink from your bin directory:
+
+<pre><code> ln -s $HOME/jruby/bin/jruby /usr/bin/jruby</code></pre>
+
+Next install the celerity gem for JRuby:
+
+<pre><code> jruby -S gem install celerity</code></pre>
+
+Now (assuming you have a Rails application set up already) install Culerity as a Rails Plugin:
+
+<pre><code> cd RAILS_ROOT
+ git clone git://github.com/langalex/culerity.git</code></pre>
+
+or as a gem: (definitely preferred)
+
+<pre><code> gem install langalex-culerity --source http://gems.github.com</code></pre>
+ 
+Run the RSpec, Cucumber and Culerity generators:
+
+<pre><code>
+ cd RAILS_ROOT
+ script/generate rspec
+ script/generate cucumber
+ script/generate culerity
+</code></pre>
+ 
+This creates the features folder and a file common_celerity.rb into your application. This file contains step definitions for basic interactions like clicking links or filling out forms.
+
+After you have written a first feature you can run it just like you would run a standard cucumber feature. The only difference is that you have to start a web server (e.g. mongrel) with the test environment enabled beforehand.
+
+NOTE: The default port for this server is 3001. You can change this in features/step_definitions/common_celerity.rb
+
+ 
+<pre><code> script/server -p 3001 -e test
+ cucumber features/my_feature.feature
+</code></pre>
+
+h2. How does it work
+
+While Celerity is based on Java and requires JRuby to run, with Culerity you can still run your tests in your own Ruby Environment. When you run your features a separate JRuby process for Celerity is spawned and all Celerity Commands are redirected to this other process.
+
+h2. Troubleshooting
+
+I get a broken pipe error:
+* make sure JRuby is installed and in your path: running _jruby -v_ should not produce an error
+
+I get _Connection Refused_ errors
+* make sure you have started a server in the test environment that runs on port 3001
+
+My application can't find the data I create in my steps
+* make sure you have disabled transactional fixtures in your env.rb
+
+My database is not cleared automatically between scenarios
+* Rails can't clean the database because you had to disable transactional fixtures - which only work if your test process is the same as your web server process. Hence you have to clean your database manually. A quick way would be:
+
+<pre><code>Before do
+  [User, .... all your models].each do |model|
+    mode.delete_all
+  end
+end
+</code></pre>
+
+I want to test emails but the ActionMailer::Base.deliveries array is always empty.
+* that's because the :test delivery method stores all emails in memory, but now that your test process is not the same as your rails process you don't have access to that array. install the http://github.com/ngty/action_mailer_cache_delivery plugin to access the emails in your rails process via a temporary file
+
+
+h2. Links to Celerity documentation
+
+* "How to select elements":http://celerity.rubyforge.org/yard/Celerity/Container.html
+* "FAQ":http://wiki.github.com/jarib/celerity/faq
+* "Tutorial":http://wiki.github.com/jarib/celerity/getting-started
+* "API docs":http://celerity.rubyforge.org/yard/
+
+h2. Links
+
+* "cucumber":http://github.com/aslakhellesoy/cucumber/wikis
+* "celerity":http://celerity.rubyforge.org
+* "jruby":http://jruby.codehaus.org
+* "rspec":http://rspec.info
+* "htmlunit":http://htmlunit.sourceforge.net/
+
+h2. Contact
+
+Written 2009 by Alexander Lang, contact alex[at]upstream-berlin.com or http://github.com/langalex, released under the MIT license

data/Rakefile

@@ -0,0 +1,42 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rcov/rcovtask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "culerity"
+    s.summary = %Q{Culerity integrates Cucumber and Celerity in order to test your application's full stack.}
+    s.email = "alex@upstream-berlin.com"
+    s.homepage = "http://github.com/langalex/culerity"
+    s.description = "Culerity integrates Cucumber and Celerity in order to test your application's full stack."
+    s.authors = ["Alexander Lang"]
+    s.add_dependency 'cucumber' 
+    s.add_dependency 'rspec' 
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = 'spec/**/*_spec.rb'
+  t.verbose = false
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Culerity'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Rcov::RcovTask.new do |t|
+  t.libs << 'spec'
+  t.test_files = FileList['spec/**/*_spec.rb']
+  t.verbose = true
+end
+
+task :default => :test

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 5

data/culerity.gemspec

@@ -0,0 +1,62 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{culerity}
+  s.version = "0.1.5"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Alexander Lang"]
+  s.date = %q{2009-05-13}
+  s.description = %q{Culerity integrates Cucumber and Celerity in order to test your application's full stack.}
+  s.email = %q{alex@upstream-berlin.com}
+  s.extra_rdoc_files = [
+    "README.textile"
+  ]
+  s.files = [
+    "MIT-LICENSE",
+     "README.textile",
+     "Rakefile",
+     "VERSION.yml",
+     "culerity.gemspec",
+     "generators/culerity/culerity_generator.rb",
+     "generators/culerity/templates/common_celerity.rb",
+     "init.rb",
+     "lib/culerity.rb",
+     "lib/culerity/celerity_server.rb",
+     "lib/culerity/remote_browser_proxy.rb",
+     "lib/culerity/remote_object_proxy.rb",
+     "rails/init.rb",
+     "spec/celerity_server_spec.rb",
+     "spec/remote_browser_proxy_spec.rb",
+     "spec/remote_object_proxy_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/langalex/culerity}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Culerity integrates Cucumber and Celerity in order to test your application's full stack.}
+  s.test_files = [
+    "spec/celerity_server_spec.rb",
+     "spec/remote_browser_proxy_spec.rb",
+     "spec/remote_object_proxy_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<cucumber>, [">= 0"])
+      s.add_runtime_dependency(%q<rspec>, [">= 0"])
+    else
+      s.add_dependency(%q<cucumber>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<cucumber>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+  end
+end

data/generators/culerity/culerity_generator.rb

@@ -0,0 +1,20 @@
+class CulerityGenerator < Rails::Generator::Base
+  
+  def initialize(runtime_args, runtime_options = {})
+    Dir.mkdir('features/step_definitions') unless File.directory?('features/step_definitions')
+    super
+  end
+
+  def manifest
+    record do |m|
+      m.template  'common_celerity.rb', 'features/step_definitions/common_celerity.rb'
+    end
+  end
+
+protected
+
+  def banner
+    "Usage: #{$0} culerity"
+  end
+
+end

data/generators/culerity/templates/common_celerity.rb

@@ -0,0 +1,87 @@
+require 'culerity'
+
+Before do
+  $server ||= Culerity::run_server
+  $browser = Culerity::RemoteBrowserProxy.new $server, {:browser => :firefox}
+  @host = 'http://localhost:3001'
+end
+
+at_exit do
+  $browser.exit
+  $server.close
+end
+
+When /I press "(.*)"/ do |button|
+  $browser.button(:text, button).click
+  assert_successful_response
+end
+
+When /I follow "(.*)"/ do |link|
+  $browser.link(:text, /#{link}/).click
+  assert_successful_response
+end
+
+When /I fill in "(.*)" for "(.*)"/ do |value, field|
+  $browser.text_field(:id, find_label(field).for).set(value)
+end
+
+When /I check "(.*)"/ do |field|
+  $browser.check_box(:id, find_label(field).for).set(true)
+end
+
+When /^I uncheck "(.*)"$/ do |field|
+  $browser.check_box(:id, find_label(field).for).set(false)
+end
+
+When /I select "(.*)" from "(.*)"/ do |value, field|
+  $browser.select_list(:id, find_label(field).for).select value
+end
+
+When /I choose "(.*)"/ do |field|
+  $browser.radio(:id, find_label(field).for).set(true)
+end
+
+When /I go to (.+)/ do |path|
+  $browser.goto @host + path_to(path)
+  assert_successful_response
+end
+
+When /I wait for the AJAX call to finish/ do
+  $browser.wait
+end
+
+Then /I should see "(.*)"/ do |text|
+  # if we simply check for the browser.html content we don't find content that has been added dynamically, e.g. after an ajax call
+  div = $browser.div(:text, /#{text}/)
+  begin
+    div.html
+  rescue
+    #puts $browser.html
+    raise("div with '#{text}' not found")
+  end
+end
+
+Then /I should not see "(.*)"/ do |text|
+  div = $browser.div(:text, /#{text}/).html rescue nil
+  div.should be_nil
+end
+
+def find_label(text)
+  $browser.label :text, text
+end
+
+def assert_successful_response
+  status = $browser.page.web_response.status_code
+  if(status == 302 || status == 301)
+    location = $browser.page.web_response.get_response_header_value('Location')
+    puts "Being redirected to #{location}"
+    $browser.goto location
+    assert_successful_response
+  elsif status != 200
+    tmp = Tempfile.new 'culerity_results'
+    tmp << $browser.html
+    tmp.close
+    `open -a /Applications/Safari.app #{tmp.path}`
+    raise "Brower returned Response Code #{$browser.page.web_response.status_code}"
+  end
+end

data/init.rb

@@ -0,0 +1 @@
+require 'rails/init'

data/lib/culerity/celerity_server.rb

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'celerity'
+
+
+module Culerity
+  class CelerityServer
+    
+    def initialize(_in, _out)
+      @proxies = {}
+      @browser_options = {}
+      
+      while(true)
+        call = eval _in.gets.to_s.strip
+        return  if call == ["_exit_"]
+        unless call.nil?
+          begin
+            result = target(call.first).send call[1], *call[2..-1]
+            _out << "[:return, #{proxify result}]\n"
+          rescue => e
+            _out << "[:exception, \"#{e.class.name}\", #{e.message.inspect}, #{e.backtrace.inspect}]\n"
+          end
+        end
+      end
+      
+    end
+    
+    private
+    
+    def configure_browser(options)
+      @browser_options = options
+    end
+    
+    def browser
+      @browser ||= Celerity::Browser.new @browser_options || {}
+    end
+    
+    def target(object_id)
+      if object_id == 'browser'
+        browser
+      elsif object_id == 'celerity'
+        self
+      else
+        @proxies[object_id]
+      end
+    end
+    
+    def proxify(result)
+      if result.is_a?(Array)
+        result.map {|x| proxify(x) }.inspect
+      elsif [String, TrueClass, FalseClass, Fixnum, Float, NilClass].include?(result.class)
+        result.inspect
+      else
+        @proxies[result.object_id] = result
+        "Culerity::RemoteObjectProxy.new(#{result.object_id}, @io)"
+      end
+    end
+  end
+end

data/lib/culerity/remote_browser_proxy.rb

@@ -0,0 +1,21 @@
+module Culerity
+
+  class RemoteBrowserProxy < RemoteObjectProxy
+    def initialize(io, browser_options = {})
+      @io = io
+      unless browser_options.empty?
+        @remote_object_id = 'celerity'
+        configure_browser browser_options 
+        @remote_object_id = nil
+      end
+      
+    end
+    
+    private
+    
+    def remote_object_id
+      (@remote_object_id || 'browser').inspect
+    end
+  end
+  
+end

data/lib/culerity/remote_object_proxy.rb

@@ -0,0 +1,40 @@
+module Culerity
+  
+  class CulerityException < StandardError
+    def initialize(message, backtrace)
+      super message
+      #self.backtrace = backtrace
+    end
+  end
+
+  class RemoteObjectProxy
+    def initialize(remote_object_id, io)
+      @remote_object_id = remote_object_id
+      @io = io
+    end
+    
+    def method_missing(name, *args)
+      @io << "[#{remote_object_id}, \"#{name}\", #{args.map{|a| a.inspect}.join(', ')}]\n"
+      process_result @io.gets.to_s.strip
+    end
+    
+    def exit
+      @io << '["_exit_"]'
+    end
+    
+    private
+    
+    def process_result(result)
+      res = eval result
+      if res.first == :return
+        res[1]
+      elsif res.first == :exception
+        raise CulerityException.new("#{res[1]}: #{res[2]}", res[3])
+      end
+    end
+    
+    def remote_object_id
+      @remote_object_id
+    end
+  end
+end

data/lib/culerity.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/culerity/remote_object_proxy'
+require File.dirname(__FILE__) + '/culerity/remote_browser_proxy'
+
+module Culerity
+
+  def self.run_server
+    IO.popen("jruby #{__FILE__}", 'r+')
+  end
+  
+end
+
+if __FILE__ == $0
+  require File.dirname(__FILE__) + '/culerity/celerity_server'
+  Culerity::CelerityServer.new STDIN, STDOUT
+end
+

data/rails/init.rb

@@ -0,0 +1 @@
+require 'culerity'

data/spec/celerity_server_spec.rb

@@ -0,0 +1,77 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Culerity::CelerityServer do
+  before(:each) do
+    @browser = stub 'browser'
+    Celerity::Browser.stub!(:new).and_return(@browser)
+  end
+  
+  it "should pass the method call to the selerity browser" do
+    @browser.should_receive(:goto).with('/homepage')
+    _in = stub 'in'
+    _in.stub!(:gets).and_return("[\"browser\", \"goto\", \"/homepage\"]\n", "[\"_exit_\"]\n")
+    _out = stub 'out', :<< => nil
+    Culerity::CelerityServer.new(_in, _out)
+  end
+  
+  it "should send back the return value of the call" do
+    @browser.stub!(:goto).and_return(true)
+    _in = stub 'in'
+    _in.stub!(:gets).and_return("[\"browser\", \"goto\", \"/homepage\"]\n", "[\"_exit_\"]\n")
+    _out = stub 'out'
+    _out.should_receive(:<<).with("[:return, true]\n")
+    Culerity::CelerityServer.new(_in, _out)
+  end
+  
+  it "should ignore empty inputs" do
+    _in = stub 'in'
+    _in.stub!(:gets).and_return("\n", "[\"_exit_\"]\n")
+    _out = stub 'out'
+    _out.should_not_receive(:<<)
+    Culerity::CelerityServer.new(_in, _out)
+  end
+  
+  it "should send back a proxy if the return value is not a string, number, nil or boolean" do
+    @browser.stub!(:goto).and_return(stub('123', :object_id => 456))
+    _in = stub 'in'
+    _in.stub!(:gets).and_return("[\"browser\", \"goto\", \"/homepage\"]\n", "[\"_exit_\"]\n")
+    _out = stub 'out'
+    _out.should_receive(:<<).with("[:return, Culerity::RemoteObjectProxy.new(456, @io)]\n")
+    Culerity::CelerityServer.new(_in, _out)
+  end
+  
+  it "should pass the method call to a proxy" do
+    proxy = stub('123', :object_id => 456)
+    @browser.stub!(:goto).and_return(proxy)
+    _in = stub 'in'
+    _in.stub!(:gets).and_return("[\"browser\", \"goto\", \"/homepage\"]\n", "[456, \"goto_2\", \"1\"]", "[\"_exit_\"]\n")
+    _out = stub 'out', :<< => nil
+    proxy.should_receive(:goto_2).with('1')
+    Culerity::CelerityServer.new(_in, _out)
+  end
+  
+  it "should configure the browser" do
+    _in = stub 'in'
+    _in.stub!(:gets).and_return('["celerity", "configure_browser", {:browser=>:firefox}]' + "\n", '["browser", "goto", "/homepage"]' + "\n", "[\"_exit_\"]\n")
+    Celerity::Browser.should_receive(:new).with(:browser => :firefox)
+    Culerity::CelerityServer.new(_in, stub.as_null_object)
+  end
+  
+  it "should pass multiple method calls" do
+    @browser.should_receive(:goto).with('/homepage')
+    @browser.should_receive(:goto).with('/page2')
+    _in = stub 'in'
+    _in.stub!(:gets).and_return("[\"browser\", \"goto\", \"/homepage\"]\n", "[\"browser\", \"goto\", \"/page2\"]\n", "[\"_exit_\"]\n")
+    _out = stub 'out', :<< => nil
+    Culerity::CelerityServer.new(_in, _out)
+  end
+  
+  it "should return an exception" do
+    @browser.stub!(:goto).and_raise(RuntimeError.new('test exception with "quotes"'))
+    _in = stub 'in'
+    _in.stub!(:gets).and_return("[\"browser\", \"goto\", \"/homepage\"]\n", "[\"_exit_\"]\n")
+    _out = stub 'out'
+    _out.should_receive(:<<).with(/^\[:exception, \"RuntimeError\", \"test exception with \\\"quotes\\\"\", \[.*\]\]\n$/)
+    Culerity::CelerityServer.new(_in, _out)
+  end
+end

data/spec/remote_browser_proxy_spec.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Culerity::RemoteBrowserProxy do
+  it "should send the serialized method call to the output" do
+    io = stub 'io', :gets => '[return, :okay]'
+    io.should_receive(:<<).with("[\"browser\", \"goto\", \"/homepage\"]\n")
+    proxy = Culerity::RemoteBrowserProxy.new io
+    proxy.goto '/homepage'
+  end
+  
+  it "should return the deserialized return value" do
+    io = stub 'io', :gets => "[:return, :okay]\n", :<< => nil
+    proxy = Culerity::RemoteBrowserProxy.new io
+    proxy.goto.should == :okay
+  end
+  
+  it "should send the brower options to the remote server" do
+    io = stub 'io', :gets => "[:return, :okay]"
+    io.should_receive(:<<).with('["celerity", "configure_browser", {:browser=>:firefox}]' + "\n")
+    proxy = Culerity::RemoteBrowserProxy.new io, {:browser => :firefox}
+  end
+  
+end

data/spec/remote_object_proxy_spec.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Culerity::RemoteObjectProxy do
+  it "should send the serialized method call to the output" do
+    io = stub 'io', :gets => '[:return]'
+    io.should_receive(:<<).with("[345, \"goto\", \"/homepage\"]\n")
+    proxy = Culerity::RemoteObjectProxy.new 345, io
+    proxy.goto '/homepage'
+  end
+  
+  it "should return the deserialized return value" do
+    io = stub 'io', :gets => "[:return, :okay]\n", :<< => nil
+    proxy = Culerity::RemoteObjectProxy.new 345, io
+    proxy.goto.should == :okay
+  end
+  
+  it "should raise the received exception" do
+    io = stub 'io', :gets => "[:exception, \"RuntimeError\", \"test exception\", []]", :<< => nil
+    proxy = Culerity::RemoteObjectProxy.new 345, io
+    lambda {
+      proxy.goto '/home'
+    }.should raise_error(Culerity::CulerityException)
+  end
+  
+  it "should send exit" do
+    io = stub 'io', :gets => '[:return]'
+    io.should_receive(:<<).with('["_exit_"]')
+    proxy = Culerity::RemoteObjectProxy.new 345, io
+    proxy.exit
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+if RUBY_PLATFORM != 'java'
+  puts "You need JRuby to run these specs"
+  exit -1
+end
+
+require File.dirname(__FILE__) + '/../lib/culerity'
+require File.dirname(__FILE__) + '/../lib/culerity/celerity_server'

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: caius-culerity
+version: !ruby/object:Gem::Version 
+  version: 0.1.5
+platform: ruby
+authors: 
+- Alexander Lang
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-13 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Culerity integrates Cucumber and Celerity in order to test your application's full stack.
+email: alex@upstream-berlin.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.textile
+files: 
+- MIT-LICENSE
+- README.textile
+- Rakefile
+- VERSION.yml
+- culerity.gemspec
+- generators/culerity/culerity_generator.rb
+- generators/culerity/templates/common_celerity.rb
+- init.rb
+- lib/culerity.rb
+- lib/culerity/celerity_server.rb
+- lib/culerity/remote_browser_proxy.rb
+- lib/culerity/remote_object_proxy.rb
+- rails/init.rb
+- spec/celerity_server_spec.rb
+- spec/remote_browser_proxy_spec.rb
+- spec/remote_object_proxy_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/langalex/culerity
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Culerity integrates Cucumber and Celerity in order to test your application's full stack.
+test_files: 
+- spec/celerity_server_spec.rb
+- spec/remote_browser_proxy_spec.rb
+- spec/remote_object_proxy_spec.rb
+- spec/spec_helper.rb