fletcherm-culerity 0.2.5

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,36 @@
+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 delete file "features/support/env.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
+      And I setup the culerity javascript helpers
+  
+  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/culerity_steps.rb" is created
+    Then file "config/environments/culerity_development.rb" is created
+    Then file "config/environments/culerity_continuousintegration.rb" is created
+
+    When 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,23 @@
+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 delete file "features/support/env.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
+      And I setup the culerity javascript helpers
+  
+  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

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/culerity_steps.rb')
+  end
+end
+

data/features/step_definitions/jruby_steps.rb

@@ -0,0 +1,11 @@
+Given /^I have jruby installed$/ do
+  @jruby_cmd = `which jruby`.strip
+  raise "Need to setup @jruby_cmd to test jruby environment" if @jruby_cmd.blank?
+end
+
+Then /^the gem "([^\"]*)" is installed into jruby environment$/ do |gem_name|
+  raise "Need to setup @jruby_cmd to test jruby environment" if @jruby_cmd.blank?
+  gem_list = `#{@jruby_cmd} -S gem list #{gem_name}`
+  gem_list.should =~ /#{gem_name}/
+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
+
+When /^I setup the culerity javascript helpers$/ do
+  `cp #{File.dirname(__FILE__) + "/../fixtures/jquery"} #{File.join(@active_project_folder, 'public', 'javascripts', 'jquery.js')}`
+  in_project_folder do
+    _index = File.read('public/index.html')
+    File.open('public/index.html', 'w') do |f|
+      f << _index.sub('</head>', '<script type="text/javascript" src="javascripts/jquery.js"></script><script type="text/javascript" src="javascripts/culerity.js"></script><script type="text/javascript">jQuery.noConflict();</script></head>')
+    end
+  end
+end
+
+After do
+  in_project_folder do
+    Given 'I invoke task "rake culerity:rails:stop"'
+  end
+end

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/init.rb

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

data/lib/culerity.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/culerity/remote_object_proxy'
+require File.dirname(__FILE__) + '/culerity/remote_browser_proxy'
+require File.dirname(__FILE__) + '/culerity/jruby_runner'
+
+Symbol.class_eval do
+  def to_proc
+    Proc.new{|object| object.send(self)}
+  end
+end unless :symbol.respond_to?(:to_proc)
+
+module Culerity
+
+  module ServerCommands
+    def exit_server
+      self << '["_exit_"]'
+      Process.kill(6, self.pid.to_i)
+    end
+
+    def close_browsers
+      self.puts '["_close_browsers_"]'
+    end
+  end
+
+  def self.run_server
+    IO.popen("#{Culerity::JRubyRunner.cmd} #{__FILE__}", 'r+').extend(ServerCommands)
+  end
+  
+  def self.run_rails(options = {})
+    if defined?(Rails) && !File.exists?("tmp/culerity_rails_server.pid")
+      puts "WARNING: Speed up execution by running 'rake culerity:rails:start'"
+      port        = options[:port] || 3001
+      environment = options[:environment] || 'culerity_development'
+      rails_server = IO.popen("script/server -e #{environment} -p #{port}", 'r+')
+      sleep 5
+      rails_server
+    end
+  end
+end
+
+if __FILE__ == $0
+  require File.dirname(__FILE__) + '/culerity/celerity_server'
+  Culerity::CelerityServer.new STDIN, STDOUT
+end
+

data/lib/culerity/celerity_server.rb

@@ -0,0 +1,81 @@
+require 'rubygems'
+require 'celerity'
+
+
+module Culerity
+  class CelerityServer
+    
+    def initialize(_in, _out)
+      @proxies = {}
+      @browsers = []
+
+      while(true)
+        call = eval _in.gets.to_s.strip
+        return if call == ["_exit_"]
+        next(close_browsers) if call == ["_close_browsers_"]
+        unless call.nil?
+          begin
+            # 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
+    
+    private
+    
+    def configure_browser(options)
+      @browser_options = options
+    end
+    
+    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(\d+)/
+        browser($1.to_i)
+      elsif object_id == 'celerity'
+        self
+      else
+        @proxies[object_id]
+      end
+    end
+    
+    def proxify(result)
+      if result.is_a?(Array)
+        "[" + result.map {|x| proxify(x) }.join(", ") + "]"
+      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