caius-culerity 0.1.7 → 0.1.8

data/VERSION.yml

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

data/culerity.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{culerity}
-  s.version = "0.1.7"
+  s.version = "0.1.8"
 
   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-06-26}
   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 = [

data/lib/culerity/celerity_server.rb

@@ -11,10 +11,17 @@ module Culerity
       
       while(true)
         call = eval _in.gets.to_s.strip
-        return  if call == ["_exit_"]
+        return if call == ["_exit_"]
         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"
@@ -44,11 +51,11 @@ module Culerity
       end
     end
     
-    def proxify(result)
+    def proxify(result, in_array = false)
       if result.is_a?(Array)
-        result.map {|x| proxify(x) }.inspect
+        result.map {|x| proxify(x, true) }.inspect
       elsif [String, TrueClass, FalseClass, Fixnum, Float, NilClass].include?(result.class)
-        result.inspect
+        in_array ? result : result.inspect
       else
         @proxies[result.object_id] = result
         "Culerity::RemoteObjectProxy.new(#{result.object_id}, @io)"

data/lib/culerity/remote_browser_proxy.rb

@@ -42,6 +42,19 @@ module Culerity
       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

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,7 +54,21 @@ 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

data/spec/remote_browser_proxy_spec.rb

@@ -21,31 +21,39 @@ describe Culerity::RemoteBrowserProxy do
   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 nil
     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 nil
+    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 nil
     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 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

@@ -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: caius-culerity
 version: !ruby/object:Gem::Version 
-  version: 0.1.7
+  version: 0.1.8
 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-06-26 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency