culerity 0.2.3

data/.gitignore

@@ -0,0 +1,6 @@
+coverage
+rdoc
+pkg
+tmp
+*.sw?
+*.gem

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,106 @@
+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>
+
+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.
+
+Culerity is a Ruby-side interface to celerity running on JRuby. To install it:
+
+<pre><code> rake culerity:install</code></pre>
+ 
+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.
+
+<pre><code> rake culerity:rails:start
+ cucumber features/my_feature.feature
+</code></pre>
+
+The Rails instance uses a special environment culerity_development.
+
+When you have finished running culerity/cucumber you can turn off the Rails instance:
+
+NOTE: The default port for this server is 3001. You can change this in features/step_definitions/common_celerity.rb
+
+<pre><code> rake culerity:rails:stop</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,43 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+# require 'rcov/rcovtask'
+
+begin
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  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: 2
+:patch: 3

data/culerity.gemspec

@@ -0,0 +1,78 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{culerity}
+  s.version = "0.2.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Alexander Lang"]
+  s.date = %q{2009-09-08}
+  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 = [
+    ".gitignore",
+     "MIT-LICENSE",
+     "README.textile",
+     "Rakefile",
+     "VERSION.yml",
+     "culerity.gemspec",
+     "features/fixtures/sample_feature",
+     "features/installing_culerity.feature",
+     "features/running_cucumber_without_explicitly_running_external_services.feature",
+     "features/step_definitions/common_steps.rb",
+     "features/step_definitions/culerity_setup_steps.rb",
+     "features/step_definitions/jruby_steps.rb",
+     "features/step_definitions/rails_setup_steps.rb",
+     "features/support/common.rb",
+     "features/support/env.rb",
+     "features/support/matchers.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",
+     "rails_generators/culerity/culerity_generator.rb",
+     "rails_generators/culerity/templates/config/environments/culerity_continuousintegration.rb",
+     "rails_generators/culerity/templates/config/environments/culerity_development.rb",
+     "rails_generators/culerity/templates/features/step_definitions/common_celerity_steps.rb",
+     "rails_generators/culerity/templates/lib/tasks/culerity.rake",
+     "script/console",
+     "script/destroy",
+     "script/generate",
+     "spec/celerity_server_spec.rb",
+     "spec/remote_browser_proxy_spec.rb",
+     "spec/remote_object_proxy_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/langalex/culerity}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  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 = 3
+
+    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/features/fixtures/sample_feature

@@ -0,0 +1,14 @@
+Feature: Check that default Rails index.html shows information
+  In order to value
+  As a role
+  I want feature
+
+  Scenario: Check javascript runs on static file
+    Given I go to the homepage
+    Then I should not see "Rails version"
+    When I follow "About your application’s environment"
+    And I wait for the AJAX call to finish
+    Then I should see "No route matches"
+  
+  
+  

data/features/installing_culerity.feature

@@ -0,0 +1,46 @@
+Feature: Installing culerity
+  In order to not have to use f@#$ing selenium and receive hate into our lives
+  As a self-respective Rails/JavaScript developer
+  I want to install culerity into my Rails app
+
+  Background:
+    Given a Rails app
+    And I run executable "script/generate" with arguments "cucumber"
+    And I delete file "features/step_definitions/webrat_steps.rb"
+    And I copy the project generators into "vendor/generators"
+    And I invoke task "rake db:migrate"
+    When I run executable "script/generate" with arguments "culerity"
+    And I setup load path to local code
+  
+  Scenario: Install culerity and setup jruby environment
+    Given I have jruby installed
+    When I invoke task "rake culerity:install"
+    Then the gem "jarib-celerity" is installed into jruby environment
+
+  Scenario: Install culerity and test the rails start + stop tasks
+    When I invoke task "rake culerity:rails:start"
+    Then file "tmp/culerity_rails_server.pid" is created
+    And I invoke task "rake culerity:rails:stop"
+    Then file "tmp/culerity_rails_server.pid" is not created
+
+  Scenario: Install culerity into a Rails app and check it works
+    Then file "features/step_definitions/common_celerity_steps.rb" is created
+    Then file "config/environments/culerity_development.rb" is created
+    Then file "config/environments/culerity_continuousintegration.rb" is created
+    
+    And I run executable "cucumber" with arguments "features/"
+    Then I should see "0 scenarios"
+    And I should see "0 steps"
+    
+    Given I invoke task "rake culerity:rails:start"
+    
+    When I add a feature file to test Rails index.html default file
+    And I run executable "cucumber" with arguments "features/"
+    Then I should see "1 scenario"
+    And I should see "5 steps (5 passed)"
+    And I should not see "WARNING: Speed up executing by running 'rake culerity:rails:start'"
+
+  
+  
+  
+  

data/features/running_cucumber_without_explicitly_running_external_services.feature

@@ -0,0 +1,24 @@
+Feature: Running cucumber without explicitly running external services
+  In order to reduce learning cost of using culerity
+  As a rails developer
+  I want the headless browser and rails processes to launch and shutdown automatically
+
+  Background:
+    Given a Rails app
+    And I run executable "script/generate" with arguments "cucumber"
+    And I delete file "features/step_definitions/webrat_steps.rb"
+    And I copy the project generators into "vendor/generators"
+    And I invoke task "rake db:migrate"
+    When I run executable "script/generate" with arguments "culerity"
+    And I setup load path to local code
+  
+  Scenario: Successfully run scenarios without requiring celerity or rails processes running
+    When I add a feature file to test Rails index.html default file
+    And I run executable "cucumber" with arguments "features/"
+    Then file "tmp/culerity_rails_server.pid" is not created
+    And I should see "1 scenario"
+    And I should see "5 steps (5 passed)"
+    And I should see "WARNING: Speed up execution by running 'rake culerity:rails:start'"
+  
+  
+  

data/features/step_definitions/common_steps.rb

@@ -0,0 +1,175 @@
+Given /^this project is active project folder/ do
+  @active_project_folder = File.expand_path(File.dirname(__FILE__) + "/../..")
+end
+
+Given /^env variable \$([\w_]+) set to "(.*)"/ do |env_var, value|
+  ENV[env_var] = value
+end
+
+Given /I delete (folder|file) "([^\"]*)"/ do |type, folder|
+  in_project_folder { FileUtils.rm_rf folder }
+end
+
+When /^I invoke "(.*)" generator with arguments "(.*)"$/ do |generator, arguments|
+  @stdout = StringIO.new
+  in_project_folder do
+    if Object.const_defined?("APP_ROOT")
+      APP_ROOT.replace(FileUtils.pwd)
+    else 
+      APP_ROOT = FileUtils.pwd
+    end
+    run_generator(generator, arguments.split(' '), SOURCES, :stdout => @stdout)
+  end
+  File.open(File.join(@tmp_root, "generator.out"), "w") do |f|
+    @stdout.rewind
+    f << @stdout.read
+  end
+end
+
+When /^I run executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  in_project_folder do
+    system "#{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When /^I run project executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  in_project_folder do
+    system "ruby #{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When /^I run local executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  executable = File.expand_path(File.join(File.dirname(__FILE__), "/../../bin", executable))
+  in_project_folder do
+    system "ruby #{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When /^I invoke task "rake (.*)"/ do |task|
+  @stdout = File.expand_path(File.join(@tmp_root, "rake.out"))
+  @stderr = File.expand_path(File.join(@tmp_root, "rake.err"))
+  in_project_folder do
+    system "rake #{task} --trace > #{@stdout} 2> #{@stderr}"
+  end
+  File.read(@stderr).should_not =~ /rake aborted!/
+end
+
+Then /^folder "(.*)" (is|is not) created/ do |folder, is|
+  in_project_folder do
+    File.exists?(folder).should(is == 'is' ? be_true : be_false)
+  end
+end
+
+Then /^file "(.*)" (is|is not) created/ do |file, is|
+  in_project_folder do
+    File.exists?(file).should(is == 'is' ? be_true : be_false)
+  end
+end
+
+Then /^file with name matching "(.*)" is created/ do |pattern|
+  in_project_folder do
+    Dir[pattern].should_not be_empty
+  end
+end
+
+Then /^file "(.*)" contents (does|does not) match \/(.*)\// do |file, does, regex|
+  in_project_folder do
+    actual_output = File.read(file)
+    (does == 'does') ?
+      actual_output.should(match(/#{regex}/)) :
+      actual_output.should_not(match(/#{regex}/))
+  end
+end
+
+Then /gem file "(.*)" and generated file "(.*)" should be the same/ do |gem_file, project_file|
+  File.exists?(gem_file).should be_true
+  File.exists?(project_file).should be_true
+  gem_file_contents = File.read(File.dirname(__FILE__) + "/../../#{gem_file}")
+  project_file_contents = File.read(File.join(@active_project_folder, project_file))
+  project_file_contents.should == gem_file_contents
+end
+
+Then /^(does|does not) invoke generator "(.*)"$/ do |does_invoke, generator|
+  actual_output = File.read(@stdout)
+  does_invoke == "does" ?
+    actual_output.should(match(/dependency\s+#{generator}/)) :
+    actual_output.should_not(match(/dependency\s+#{generator}/))
+end
+
+Then /help options "(.*)" and "(.*)" are displayed/ do |opt1, opt2|
+  actual_output = File.read(@stdout)
+  actual_output.should match(/#{opt1}/)
+  actual_output.should match(/#{opt2}/)
+end
+
+Then /^I should see "([^\"]*)"$/ do |text|
+  actual_output = File.read(@stdout)
+  actual_output.should contain(text)
+end
+
+Then /^I should not see "([^\"]*)"$/ do |text|
+  actual_output = File.read(@stdout)
+  actual_output.should_not contain(text)
+end
+
+Then /^I should see$/ do |text|
+  actual_output = File.read(@stdout)
+  actual_output.should contain(text)
+end
+
+Then /^I should not see$/ do |text|
+  actual_output = File.read(@stdout)
+  actual_output.should_not contain(text)
+end
+
+Then /^I should see exactly$/ do |text|
+  actual_output = File.read(@stdout)
+  actual_output.should == text
+end
+
+Then /^I should see all (\d+) tests pass/ do |expected_test_count|
+  expected = %r{^#{expected_test_count} tests, \d+ assertions, 0 failures, 0 errors}
+  actual_output = File.read(@stdout)
+  actual_output.should match(expected)
+end
+
+Then /^I should see all (\d+) examples pass/ do |expected_test_count|
+  expected = %r{^#{expected_test_count} examples?, 0 failures}
+  actual_output = File.read(@stdout)
+  actual_output.should match(expected)
+end
+
+Then /^yaml file "(.*)" contains (\{.*\})/ do |file, yaml|
+  in_project_folder do
+    yaml = eval yaml
+    YAML.load(File.read(file)).should == yaml
+  end
+end
+
+Then /^Rakefile can display tasks successfully/ do
+  @stdout = File.expand_path(File.join(@tmp_root, "rakefile.out"))
+  in_project_folder do
+    system "rake -T > #{@stdout} 2> #{@stdout}"
+  end
+  actual_output = File.read(@stdout)
+  actual_output.should match(/^rake\s+\w+\s+#\s.*/)
+end
+
+Then /^task "rake (.*)" is executed successfully/ do |task|
+  @stdout.should_not be_nil
+  actual_output = File.read(@stdout)
+  actual_output.should_not match(/^Don't know how to build task '#{task}'/)
+  actual_output.should_not match(/Error/i)
+end
+
+Then /^gem spec key "(.*)" contains \/(.*)\// do |key, regex|
+  in_project_folder do
+    gem_file = Dir["pkg/*.gem"].first
+    gem_spec = Gem::Specification.from_yaml(`gem spec #{gem_file}`)
+    spec_value = gem_spec.send(key.to_sym)
+    spec_value.to_s.should match(/#{regex}/)
+  end
+end