langalex-culerity 0.1.7 → 0.2.2

data/.gitignore

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

data/README.textile

@@ -19,10 +19,6 @@ First download JRuby and unpack it to some location, for example $HOME/jruby. Ma
 
 <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
@@ -40,18 +36,27 @@ Run the RSpec, Cucumber and Culerity generators:
  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.
+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.
 
-NOTE: The default port for this server is 3001. You can change this in features/step_definitions/common_celerity.rb
+Culerity is a Ruby-side interface to celerity running on JRuby. To install it:
 
+<pre><code> rake culerity:install</code></pre>
  
-<pre><code> script/server -p 3001 -e test
+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.

data/Rakefile

@@ -1,9 +1,10 @@
 require 'rake'
 require 'rake/testtask'
 require 'rake/rdoctask'
-require 'rcov/rcovtask'
+# require 'rcov/rcovtask'
 
 begin
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
   require 'jeweler'
   Jeweler::Tasks.new do |s|
     s.name = "culerity"
@@ -33,10 +34,10 @@ Rake::RDocTask.new do |rdoc|
   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
+# 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

@@ -1,4 +1,4 @@
 --- 
+:minor: 2
+:patch: 2
 :major: 0
-:minor: 1
-:patch: 7

data/culerity.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{culerity}
-  s.version = "0.1.7"
+  s.version = "0.2.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Alexander Lang"]
-  s.date = %q{2009-06-08}
+  s.date = %q{2009-08-16}
   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 = [
@@ -19,14 +19,28 @@ Gem::Specification.new do |s|
      "Rakefile",
      "VERSION.yml",
      "culerity.gemspec",
-     "generators/culerity/culerity_generator.rb",
-     "generators/culerity/templates/common_celerity.rb",
+     "features/fixtures/sample_feature",
+     "features/installing_culerity.feature",
+     "features/step_definitions/common_steps.rb",
+     "features/step_definitions/culerity_setup_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",
@@ -35,7 +49,7 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/langalex/culerity}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.4}
+  s.rubygems_version = %q{1.3.3}
   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",

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)"
+
+  
+  
+  
+  

data/features/step_definitions/common_steps.rb

@@ -0,0 +1,171 @@
+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 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

data/features/step_definitions/culerity_setup_steps.rb

@@ -0,0 +1,7 @@
+When /^I setup load path to local code$/ do
+  project_lib_path = File.expand_path(File.dirname(__FILE__) + "/../../lib")
+  in_project_folder do
+    force_local_lib_override(:target => 'features/step_definitions/common_celerity_steps.rb')
+  end
+end
+

data/features/step_definitions/rails_setup_steps.rb

@@ -0,0 +1,36 @@
+Given /^a Rails app$/ do
+  FileUtils.chdir(@tmp_root) do
+    `rails my_project`
+  end
+  @active_project_folder = File.expand_path(File.join(@tmp_root, "my_project"))
+end
+
+Given /^I copy the project generators into "([^\"]*)"$/ do |target_folder|
+  in_project_folder do
+    FileUtils.mkdir_p(target_folder)
+  end
+  `cp -rf #{File.dirname(__FILE__) + "/../../rails_generators/*"} #{File.join(@active_project_folder, target_folder)}`
+end
+
+When /^I add a feature file to test Rails index.html default file$/ do
+  sample_feature = File.expand_path(File.dirname(__FILE__) + "/../fixtures/sample_feature")
+  in_project_folder do
+    `cp -rf #{sample_feature} features/sample.feature`
+  end
+end
+
+Given /^I run the rails server in environment "([^\"]*)"$/ do |environment|
+  in_project_folder do
+    $rails_server ||= IO.popen("script/server -e #{environment} -p 3001", 'r+')
+    File.open("tmp/culerity_rails_server.pid", "w") { |file| file << $rails_server.pid; file.flush }
+  end
+end
+
+After do
+  in_project_folder do
+    Given 'I invoke task "rake culerity:rails:stop"'
+  end
+end
+
+# rake culerity:rails:start [RAILS=culerity_development]
+# rake culerity:rails:stop

data/features/support/common.rb

@@ -0,0 +1,32 @@
+module CommonHelpers
+  def in_tmp_folder(&block)
+    FileUtils.chdir(@tmp_root, &block)
+  end
+
+  def in_project_folder(&block)
+    project_folder = @active_project_folder || @tmp_root
+    FileUtils.chdir(project_folder, &block)
+  end
+
+  def in_home_folder(&block)
+    FileUtils.chdir(@home_path, &block)
+  end
+
+  def force_local_lib_override(options = {})
+    target_path = options[:target_path] || options[:target_file] || options[:target] || 'Rakefile'
+    in_project_folder do
+      contents = File.read(target_path)
+      File.open(target_path, "w+") do |f|
+        f << "$:.unshift('#{@lib_path}')\n"
+        f << contents
+      end
+    end
+  end
+
+  def setup_active_project_folder project_name
+    @active_project_folder = File.join(@tmp_root, project_name)
+    @project_name = project_name
+  end
+end
+
+World(CommonHelpers)

data/features/support/env.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + "/../../lib/culerity"
+
+gem 'cucumber'
+require 'cucumber'
+gem 'rspec'
+require 'spec'
+
+Before do
+  @tmp_root  = File.dirname(__FILE__) + "/../../tmp"
+  @home_path = File.expand_path(File.join(@tmp_root, "home"))
+  @lib_path  = File.expand_path(File.dirname(__FILE__) + "/../../lib")
+  FileUtils.rm_rf   @tmp_root
+  FileUtils.mkdir_p @home_path
+  ENV['HOME'] = @home_path
+end
+
+require 'rubigen'
+require 'rubigen/helpers/generator_test_helper'
+include RubiGen::GeneratorTestHelper
+require 'rails_generator'
+
+SOURCES = Dir[File.dirname(__FILE__) + "/../../generators"].map do |f|
+  RubiGen::PathSource.new(:test, File.expand_path(f))
+end

data/features/support/matchers.rb

@@ -0,0 +1,11 @@
+module Matchers
+  def contain(expected)
+    simple_matcher("contain #{expected.inspect}") do |given, matcher|
+      matcher.failure_message = "expected #{given.inspect} to contain #{expected.inspect}"
+      matcher.negative_failure_message = "expected #{given.inspect} not to contain #{expected.inspect}"
+      given.index expected
+    end
+  end
+end
+
+World(Matchers)

data/lib/culerity/celerity_server.rb

@@ -7,19 +7,28 @@ module Culerity
     
     def initialize(_in, _out)
       @proxies = {}
-      @browser_options = {}
-      
+      @browsers = []
+
       while(true)
         call = eval _in.gets.to_s.strip
-        return  if call == ["_exit_"]
+        return if call == ["_exit_"]
+        next(close_browsers) if call == ["_close_browsers_"]
         unless call.nil?
           begin
-            result = target(call.first).send call[1], *call[2..-1]
+            # check if last arg is a block
+            if call.last.is_a?(Proc)
+              # pass as &call[-1]
+              result = target(call.first).send call[1], *call[2..-2], &call[-1]
+            else
+              # just call with args as normal
+              result = target(call.first).send call[1], *call[2..-1]
+            end
             _out << "[:return, #{proxify result}]\n"
           rescue => e
             _out << "[:exception, \"#{e.class.name}\", #{e.message.inspect}, #{e.backtrace.inspect}]\n"
           end
         end
+
       end
       
     end
@@ -30,13 +39,27 @@ module Culerity
       @browser_options = options
     end
     
-    def browser
-      @browser ||= Celerity::Browser.new @browser_options || {}
+    def new_browser(options, number = nil)
+      number ||= @browsers.size
+      @browsers[number] = Celerity::Browser.new(options || @browser_options || {})
+      "browser#{number}"
+    end
+
+    def close_browsers
+      @browsers.each { |browser| browser.close }
+      @browsers = []
+    end
+
+    def browser(number)
+      unless @browsers[number]
+        new_browser(nil, number)
+      end
+      @browsers[number]
     end
     
     def target(object_id)
-      if object_id == 'browser'
-        browser
+      if object_id =~ /browser(\d+)/
+        browser($1.to_i)
       elsif object_id == 'celerity'
         self
       else
@@ -55,4 +78,4 @@ module Culerity
       end
     end
   end
-end
+end

data/lib/culerity/remote_browser_proxy.rb

@@ -3,11 +3,8 @@ 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
+      @remote_object_id = "celerity".inspect
+      @remote_object_id = new_browser(browser_options).inspect
     end
     
     # 
@@ -42,11 +39,20 @@ module Culerity
       true
     end
     
-    private
     
-    def remote_object_id
-      (@remote_object_id || 'browser').inspect
+    #
+    # Specify whether to accept or reject all confirm js dialogs
+    # for the code in the block that's run.
+    # 
+    def confirm(bool, &block)
+      blk = "lambda { #{bool} }"
+      
+      self.send_remote(:add_listener, :confirm) { blk }
+      block.call
+      self.send_remote(:remove_listener, :confirm) { blk }
     end
+    
   end
   
-end
+  
+end

data/lib/culerity/remote_object_proxy.rb

@@ -1,5 +1,5 @@
 module Culerity
-  
+
   class CulerityException < StandardError
     def initialize(message, backtrace)
       super message
@@ -12,7 +12,7 @@ module Culerity
       @remote_object_id = remote_object_id
       @io = io
     end
-    
+
     #
     # Commonly used to get the HTML id attribute
     # Use `object_id` to get the local objects' id.
@@ -20,26 +20,32 @@ module Culerity
     def id
       send_remote(:id)
     end
-    
+
     def method_missing(name, *args)
       send_remote(name, *args)
     end
-    
+
     #
     # Calls the passed method on the remote object with any arguments specified.
     # Behaves the same as <code>Object#send</code>.
     #
-    def send_remote(name, *args)
-      @io << "[#{remote_object_id}, \"#{name}\", #{args.map{|a| a.inspect}.join(', ')}]\n"
+    # If you pass it a block then it will append the block as a "lambda { … }".
+    # If your block returns a lambda string ("lambda { … }") then it will be passed
+    # straight through, otherwise it will be wrapped in a lambda string before sending.
+    #
+    def send_remote(name, *args, &blk)
+      input = [remote_object_id, %Q{"#{name}"}, *args.map{|a| a.inspect}]
+      input << block_to_string(&blk) if block_given?
+      @io << "[#{input.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
@@ -48,9 +54,23 @@ module Culerity
         raise CulerityException.new("#{res[1]}: #{res[2]}", res[3])
       end
     end
-    
+
+    #
+    # Takes a block and either returns the result (if it returns "lambda { … }")
+    # or builds the lambda string with the result of the block in it.
+    #
+    # Returns a string in the format "lambda { … }"
+    #
+    def block_to_string &block
+      result = block.call.to_s
+      unless result.is_a?(String) && result[/^lambda \s* \{ .*? \}/x]
+        result = "lambda { #{result} }"
+      end
+      result
+    end
+
     def remote_object_id
       @remote_object_id
     end
   end
-end
+end

data/lib/culerity.rb

@@ -3,13 +3,48 @@ require File.dirname(__FILE__) + '/culerity/remote_browser_proxy'
 
 module Culerity
 
+  module ServerCommands
+    def exit_server
+      self << '["_exit_"]'
+      close
+    end
+
+    def close_browsers
+      self.puts '["_close_browsers_"]'
+    end
+  end
+
   def self.run_server
-    IO.popen("jruby #{__FILE__}", 'r+')
+    IO.popen("jruby #{__FILE__}", 'r+').extend(ServerCommands)
+
+    # open the two pipes that were created below
+    # while(!File.exists?("tmp/culerity_in.pipe")) 
+    #   sleep(1)
+    # end
+    # pipe_in = open("tmp/culerity_in.pipe", "w+")
+    # pipe_out = open("tmp/culerity_out.pipe", "r+")
+    
+    
+    
+    # store celerity pid in tmp/culerity_celerity.pid
+    # store server pid in tmp/culerity_rails_server.pid
+    
+    # open named pipes to communicate with celerity_server + return them
   end
   
 end
 
 if __FILE__ == $0
+  # `rm tmp/culerity_in.pipe`
+  # `mkfifo tmp/culerity_in.pipe`
+  # `rm tmp/culerity_out.pipe`
+  # `mkfifo tmp/culerity_out.pipe`
+  # 
+  # pipe_in = open("tmp/culerity_in.pipe", "r+")
+  # p pipe_in
+  # p STDIN
+  # pipe_out = open("tmp/culerity_out.pipe", "w+")
+  # 
   require File.dirname(__FILE__) + '/culerity/celerity_server'
   Culerity::CelerityServer.new STDIN, STDOUT
 end

data/rails_generators/culerity/culerity_generator.rb

@@ -0,0 +1,25 @@
+class CulerityGenerator < Rails::Generator::Base
+  
+  def manifest
+    record do |m|
+      m.directory 'features/step_definitions'
+      m.file 'features/step_definitions/common_celerity_steps.rb', 'features/step_definitions/common_celerity_steps.rb'
+      m.file 'config/environments/culerity_continuousintegration.rb', 'config/environments/culerity_continuousintegration.rb'
+      m.file 'config/environments/culerity_development.rb', 'config/environments/culerity_development.rb'
+
+      m.gsub_file 'config/database.yml', /cucumber:.*\n/, "cucumber: &CUCUMBER\n"
+
+      m.gsub_file 'config/database.yml', /\z/, "\nculerity_development:\n  <<: *CUCUMBER"
+      m.gsub_file 'config/database.yml', /\z/, "\nculerity_continuousintegration:\n  <<: *CUCUMBER"
+      
+      m.file "lib/tasks/culerity.rake", "lib/tasks/culerity.rake"
+    end
+  end
+
+protected
+
+  def banner
+    "Usage: #{$0} culerity"
+  end
+
+end

data/rails_generators/culerity/templates/config/environments/culerity_continuousintegration.rb

@@ -0,0 +1,28 @@
+# Settings specified here will take precedence over those in config/environment.rb
+
+# The production environment is meant for finished, "live" apps.
+# Code is not reloaded between requests
+config.cache_classes = true
+
+# Full error reports are disabled and caching is turned on
+config.action_controller.consider_all_requests_local = false
+config.action_controller.perform_caching             = true
+config.action_view.cache_template_loading            = true
+
+# See everything in the log (default is :info)
+# config.log_level = :debug
+
+# Use a different logger for distributed setups
+# config.logger = SyslogLogger.new
+
+# Use a different cache store in production
+# config.cache_store = :mem_cache_store
+
+# Enable serving of images, stylesheets, and javascripts from an asset server
+# config.action_controller.asset_host = "http://assets.example.com"
+
+# Disable delivery errors, bad email addresses will be ignored
+# config.action_mailer.raise_delivery_errors = false
+
+# Enable threaded mode
+# config.threadsafe!

data/rails_generators/culerity/templates/config/environments/culerity_development.rb

@@ -0,0 +1,17 @@
+config.cache_classes = false
+
+# Log error messages when you accidentally call methods on nil.
+config.whiny_nils = true
+
+# Show full error reports and disable caching
+config.action_controller.consider_all_requests_local = true
+config.action_controller.perform_caching             = false
+config.action_view.cache_template_loading            = false
+
+# Disable request forgery protection in test environment
+config.action_controller.allow_forgery_protection    = false
+
+# Tell Action Mailer not to deliver emails to the real world.
+# The :test delivery method accumulates sent emails in the
+# ActionMailer::Base.deliveries array.
+config.action_mailer.delivery_method = :test

data/{generators/culerity/templates/common_celerity.rb → rails_generators/culerity/templates/features/step_definitions/common_celerity_steps.rb}

@@ -7,8 +7,8 @@ Before do
 end
 
 at_exit do
-  $browser.exit
-  $server.close
+  $browser.exit if $browser
+  $server.close if $server
 end
 
 When /I press "(.*)"/ do |button|

data/rails_generators/culerity/templates/lib/tasks/culerity.rake

@@ -0,0 +1,34 @@
+namespace 'culerity' do
+  namespace 'rails' do
+    desc "Starts a rails server for cucumber/culerity tests"
+    task :start => :environment do
+      environment = 'culerity_development'
+      pid_file = RAILS_ROOT + "/tmp/culerity_rails_server.pid"
+      if File.exists?(pid_file)
+        puts "culerity rails server already running; if not, delete tmp/culerity_rails_server.pid and try again"
+        exit 1
+      end
+      rails_server = IO.popen("script/server -e #{environment} -p 3001", 'r+')
+      File.open(pid_file, "w") { |file| file << rails_server.pid }
+    end
+
+    desc "Stops the running rails server for cucumber/culerity tests"
+    task :stop => :environment do
+      pid_file = RAILS_ROOT + "/tmp/culerity_rails_server.pid"
+      if File.exists?(pid_file)
+        pid = File.read(pid_file).to_i
+        Process.kill(6, pid)
+        File.delete(pid_file)
+      else
+        puts "No culerity rails server running. Doing nothing."
+      end
+    end
+  end
+  
+  desc "Install required gems into jruby"
+  task :install => :environment do
+    jgem_cmd = `which jgem`.strip
+    raise "ERROR: You need to install jruby to use culerity and celerity." if jgem_cmd.blank?
+    sh "#{jgem_cmd} install jarib-celerity --source=http://gems.github.com"
+  end
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/culerity.rb'}"
+puts "Loading culerity gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/spec/celerity_server_spec.rb

@@ -6,18 +6,45 @@ describe Culerity::CelerityServer do
     Celerity::Browser.stub!(:new).and_return(@browser)
   end
   
-  it "should pass the method call to the selerity browser" do
+  it "should pass the method call to the celerity browser" do
     @browser.should_receive(:goto).with('/homepage')
     _in = stub 'in'
-    _in.stub!(:gets).and_return("[\"browser\", \"goto\", \"/homepage\"]\n", "[\"_exit_\"]\n")
+    _in.stub!(:gets).and_return("[\"browser0\", \"goto\", \"/homepage\"]\n", "[\"_exit_\"]\n")
     _out = stub 'out', :<< => nil
     Culerity::CelerityServer.new(_in, _out)
   end
+
+  it "should return the browser id when a new browser is requested" do
+    _in = stub 'in'
+    _in.stub!(:gets).and_return("[\"celerity\", \"new_browser\", {}]\n", "[\"_exit_\"]\n")
+    _out = stub 'out'
+    _out.should_receive(:<<).with("[:return, \"browser0\"]\n")
+    Culerity::CelerityServer.new(_in, _out)
+  end
+
+  it "should create a new browser with the provided options" do
+    _in = stub 'in'
+    _in.stub!(:gets).and_return("[\"celerity\", \"new_browser\", {:browser => :firefox}]\n", "[\"_exit_\"]\n")
+    Celerity::Browser.should_receive(:new).with(:browser => :firefox)
+    Culerity::CelerityServer.new(_in, stub.as_null_object)
+  end
+
+  it "should create multiple browsers and return the appropriate id for each" do
+    _in = stub 'in'
+    _in.stub!(:gets).and_return("[\"celerity\", \"new_browser\", {}]\n", "[\"celerity\", \"new_browser\", {}]\n", "[\"_exit_\"]\n")
+    Celerity::Browser.should_receive(:new).twice
+    _out = stub 'out'
+    _out.should_receive(:<<).with("[:return, \"browser0\"]\n").ordered
+    _out.should_receive(:<<).with("[:return, \"browser1\"]\n").ordered
+    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")
+    _in.stub!(:gets).and_return("[\"browser0\", \"goto\", \"/homepage\"]\n", "[\"_exit_\"]\n")
     _out = stub 'out'
     _out.should_receive(:<<).with("[:return, true]\n")
     Culerity::CelerityServer.new(_in, _out)
@@ -34,7 +61,7 @@ describe Culerity::CelerityServer do
   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")
+    _in.stub!(:gets).and_return("[\"browser0\", \"goto\", \"/homepage\"]\n", "[\"_exit_\"]\n")
     _out = stub 'out'
     _out.should_receive(:<<).with("[:return, Culerity::RemoteObjectProxy.new(456, @io)]\n")
     Culerity::CelerityServer.new(_in, _out)
@@ -44,24 +71,17 @@ describe Culerity::CelerityServer 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")
+    _in.stub!(:gets).and_return("[\"browser0\", \"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")
+    _in.stub!(:gets).and_return("[\"browser0\", \"goto\", \"/homepage\"]\n", "[\"browser0\", \"goto\", \"/page2\"]\n", "[\"_exit_\"]\n")
     _out = stub 'out', :<< => nil
     Culerity::CelerityServer.new(_in, _out)
   end
@@ -69,9 +89,9 @@ describe Culerity::CelerityServer do
   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")
+    _in.stub!(:gets).and_return("[\"browser0\", \"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
+end

data/spec/remote_browser_proxy_spec.rb

@@ -1,10 +1,13 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
 describe Culerity::RemoteBrowserProxy do
+  before(:each) do
+    @io = stub 'io', :gets => "[:return, \"browser0\"]", :<<  => nil
+  end
   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
+    @io.should_receive(:<<).with("[\"celerity\", \"new_browser\", {}]\n").ordered
+    @io.should_receive(:<<).with("[\"browser0\", \"goto\", \"/homepage\"]\n").ordered
+    proxy = Culerity::RemoteBrowserProxy.new @io
     proxy.goto '/homepage'
   end
   
@@ -15,37 +18,45 @@ describe Culerity::RemoteBrowserProxy do
   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")
+    io = stub 'io', :gets => "[:return, \"browser0\"]"
+    io.should_receive(:<<).with('["celerity", "new_browser", {:browser=>:firefox}]' + "\n")
     proxy = Culerity::RemoteBrowserProxy.new io, {:browser => :firefox}
   end
   
   it "should timeout if wait_until takes too long" do
-    io = stub 'io', :gets => "[:return, :okay]", :<< => nil
-    proxy = Culerity::RemoteBrowserProxy.new io
+    proxy = Culerity::RemoteBrowserProxy.new @io
     lambda {
-      proxy.wait_until(1) { false }
+      proxy.wait_until(0.1) { false }
     }.should raise_error(Timeout::Error)
   end
   
   it "should return successfully when wait_until returns true" do
-    io = stub 'io', :gets => "[:return, :okay]", :<< => nil
-    proxy = Culerity::RemoteBrowserProxy.new io
-    proxy.wait_until(1) { true }.should == true
+    proxy = Culerity::RemoteBrowserProxy.new @io
+    proxy.wait_until(0.1) { true }.should == true
   end
   
   it "should timeout if wait_while takes too long" do
-    io = stub 'io', :gets => "[:return, :okay]", :<< => nil
-    proxy = Culerity::RemoteBrowserProxy.new io
+    proxy = Culerity::RemoteBrowserProxy.new @io
     lambda {
-      proxy.wait_while(1) { true }
+      proxy.wait_while(0.1) { true }
     }.should raise_error(Timeout::Error)
   end
   
   it "should return successfully when wait_while returns !true" do
-    io = stub 'io', :gets => "[:return, :okay]", :<< => nil
-    proxy = Culerity::RemoteBrowserProxy.new io
-    proxy.wait_while(1) { false }.should == true
+    proxy = Culerity::RemoteBrowserProxy.new @io
+    proxy.wait_while(0.1) { false }.should == true
   end
-  
-end
+
+  it "should accept all javascript confirmation dialogs" do
+    proxy = Culerity::RemoteBrowserProxy.new @io
+
+    proxy.should_receive(:send_remote).with(:add_listener, :confirm).and_return(true)
+    proxy.should_receive(:send_remote).with(:goto, "http://example.com").and_return(true)
+    proxy.should_receive(:send_remote).with(:remove_listener, :confirm).and_return(true)
+
+    proxy.confirm(true) do
+      proxy.goto "http://example.com"
+    end
+  end
+
+end

data/spec/remote_object_proxy_spec.rb

@@ -1,13 +1,45 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
 describe Culerity::RemoteObjectProxy do
+  describe "block_to_string method" do
+    it "should return block result when result is lambda string" do
+      proxy = Culerity::RemoteObjectProxy.new nil, nil
+      block = lambda { "lambda { true}" }
+      proxy.send(:block_to_string, &block).should == "lambda { true}"
+    end
+    
+    it "should return lambda string when block result isn't a lambda string" do
+      proxy = Culerity::RemoteObjectProxy.new nil, nil
+      [true, false, "blah", 5].each do |var|
+        block = lambda { var }
+        proxy.send(:block_to_string, &block).should == "lambda { #{var} }"
+      end
+    end
+  end
+  
   it "should send the serialized method call to the output" do
     io = stub 'io', :gets => '[:return]'
-    io.should_receive(:<<).with("[345, \"goto\", \"/homepage\"]\n")
+    io.should_receive(:<<).with(%Q{[345, "goto", "/homepage"]\n})
     proxy = Culerity::RemoteObjectProxy.new 345, io
     proxy.goto '/homepage'
   end
   
+  it "should send the serialized method call with argument plus block to the output" do
+    io = stub 'io', :gets => "[:return]"
+    io.should_receive(:<<).with(%Q{[345, "method", true, lambda { true }]\n})
+    proxy = Culerity::RemoteObjectProxy.new 345, io
+    
+    proxy.send_remote(:method, true) { "lambda { true }" }
+  end
+  
+  it "should send the serialized method call without argument plus block to the output" do
+    io = stub 'io', :gets => "[:return]"
+    io.should_receive(:<<).with(%Q{[345, "method", lambda { true }]\n})
+    proxy = Culerity::RemoteObjectProxy.new 345, io
+    
+    proxy.send_remote(:method) { "lambda { true }" }
+  end
+  
   it "should return the deserialized return value" do
     io = stub 'io', :gets => "[:return, :okay]\n", :<< => nil
     proxy = Culerity::RemoteObjectProxy.new 345, io
@@ -15,7 +47,7 @@ describe Culerity::RemoteObjectProxy do
   end
   
   it "should raise the received exception" do
-    io = stub 'io', :gets => "[:exception, \"RuntimeError\", \"test exception\", []]", :<< => nil
+    io = stub 'io', :gets => %Q{[:exception, "RuntimeError", "test exception", []]}, :<< => nil
     proxy = Culerity::RemoteObjectProxy.new 345, io
     lambda {
       proxy.goto '/home'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: langalex-culerity
 version: !ruby/object:Gem::Version 
-  version: 0.1.7
+  version: 0.2.2
 platform: ruby
 authors: 
 - Alexander Lang
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-08 00:00:00 -07:00
+date: 2009-08-16 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -47,20 +47,35 @@ files:
 - Rakefile
 - VERSION.yml
 - culerity.gemspec
-- generators/culerity/culerity_generator.rb
-- generators/culerity/templates/common_celerity.rb
+- features/fixtures/sample_feature
+- features/installing_culerity.feature
+- features/step_definitions/common_steps.rb
+- features/step_definitions/culerity_setup_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
 has_rdoc: false
 homepage: http://github.com/langalex/culerity
+licenses: 
 post_install_message: 
 rdoc_options: 
 - --charset=UTF-8
@@ -81,7 +96,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: Culerity integrates Cucumber and Celerity in order to test your application's full stack.

data/generators/culerity/culerity_generator.rb

@@ -1,20 +0,0 @@
-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