drnic-culerity 0.2.1

data/lib/culerity/remote_browser_proxy.rb

@@ -0,0 +1,65 @@
+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
+    
+    # 
+    # Calls the block until it returns true or +time_to_wait+ is reached.
+    # +time_to_wait+ is 30 seconds by default
+    # 
+    # Returns true upon success
+    # Raises Timeout::Error when +time_to_wait+ is reached.
+    # 
+    def wait_until time_to_wait=30, &block
+      Timeout.timeout(time_to_wait) do
+        until block.call
+          sleep 0.1
+        end
+      end
+      true
+    end
+    
+    # 
+    # Calls the block until it doesn't return true or +time_to_wait+ is reached.
+    # +time_to_wait+ is 30 seconds by default
+    # 
+    # Returns true upon success
+    # Raises Timeout::Error when +time_to_wait+ is reached.
+    # 
+    def wait_while time_to_wait=30, &block
+      Timeout.timeout(time_to_wait) do
+        while block.call
+          sleep 0.1
+        end
+      end
+      true
+    end
+    
+    
+    #
+    # 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
+    
+    private
+    
+    def remote_object_id
+      (@remote_object_id || 'browser').inspect
+    end
+  end
+  
+end

data/lib/culerity/remote_object_proxy.rb

@@ -0,0 +1,76 @@
+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
+
+    #
+    # Commonly used to get the HTML id attribute
+    # Use `object_id` to get the local objects' id.
+    #
+    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>.
+    #
+    # 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
+        res[1]
+      elsif res.first == :exception
+        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

data/lib/culerity.rb

@@ -0,0 +1,40 @@
+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+')
+
+    # 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/init.rb

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

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/rails_generators/culerity/templates/features/step_definitions/common_celerity_steps.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 if $browser
+  $server.close if $server
+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/rails_generators/culerity/templates/lib/tasks/culerity.rake

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

@@ -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,59 @@
+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
+  
+  it "should timeout if wait_until takes too long" do
+    proxy = Culerity::RemoteBrowserProxy.new nil
+    lambda {
+      proxy.wait_until(0.1) { false }
+    }.should raise_error(Timeout::Error)
+  end
+  
+  it "should return successfully when wait_until returns true" do
+    proxy = Culerity::RemoteBrowserProxy.new nil
+    proxy.wait_until(0.1) { true }.should == true
+  end
+  
+  it "should timeout if wait_while takes too long" do
+    proxy = Culerity::RemoteBrowserProxy.new nil
+    lambda {
+      proxy.wait_while(0.1) { true }
+    }.should raise_error(Timeout::Error)
+  end
+  
+  it "should return successfully when wait_while returns !true" do
+    proxy = Culerity::RemoteBrowserProxy.new nil
+    proxy.wait_while(0.1) { false }.should == true
+  end
+
+  it "should accept all javascript confirmation dialogs" do
+    proxy = Culerity::RemoteBrowserProxy.new nil
+
+    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

@@ -0,0 +1,63 @@
+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(%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
+    proxy.goto.should == :okay
+  end
+  
+  it "should raise the received exception" do
+    io = stub 'io', :gets => %Q{[: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'