johnson 1.1.0

data/test/johnson/spidermonkey/js_land_proxy_test.rb

@@ -0,0 +1,236 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module SpiderMonkey
+    class JSLandProxyTest < Johnson::TestCase
+      module AModule
+      end
+      
+      class AClass
+        attr_reader :args
+        
+        def initialize(*args)
+          @args = args
+        end
+      end
+      
+      class Foo
+        class Inner
+        end
+        
+        def self.bar; 10; end
+
+        attr_accessor :bar
+        
+        def initialize
+          @bar = 10
+        end
+        
+        def x2(x)
+          x * 2
+        end
+        
+        def add(*args)
+          args.inject { |m,n| m += n }
+        end
+        
+        def xform(arg)
+          yield(arg)          
+        end
+      end
+      
+      class Indexable
+        def initialize
+          @store = {}
+        end
+        
+        def [](key)
+          @store[key]
+        end
+        
+        def []=(key, value)
+          @store[key] = value
+        end
+        
+        def key?(key)
+          @store.key?(key)
+        end
+      end
+
+      def setup
+        @runtime = Johnson::Runtime.new(Johnson::SpiderMonkey::Runtime)
+      end
+
+      def test_find_constants
+        assert_js_equal($LOAD_PATH, "Ruby['$LOAD_PATH']")
+      end
+
+      def test_proxies_get_reused
+        @runtime["foo"] = @runtime["bar"] = Foo.new
+        assert_js_equal(true, "foo === bar")
+      end
+
+      def test_attributes_get_added_to_ruby
+        foo = @runtime["foo"] = Foo.new
+        assert !foo.respond_to?(:johnson)
+        @runtime.evaluate("foo.johnson = 'explode';")
+        assert foo.respond_to?(:johnson)
+        assert_equal('explode', foo.johnson)
+        assert_js_equal('explode', 'foo.johnson')
+        assert !Foo.new.respond_to?(:johnson)
+      end
+
+      def test_assign_function_as_attribute
+        foo = @runtime["foo"] = Foo.new
+        assert !foo.respond_to?(:johnson)
+        f = @runtime.evaluate("foo.johnson = function() { return 'explode'; }")
+        assert foo.respond_to?(:johnson)
+        assert_equal('explode', foo.johnson)
+        assert_js_equal('explode', 'foo.johnson()')
+        assert_js_equal(f, 'foo.johnson')
+        assert !Foo.new.respond_to?(:johnson)
+      end
+
+      def test_assign_function_as_attribute_with_this
+        foo = @runtime["foo"] = Foo.new
+        @runtime.evaluate("foo.ex_squared = function(x) { return this.x2(x); }")
+        assert_equal(4, foo.ex_squared(2))
+        @runtime.evaluate("foo.ex_squared = 20;")
+        assert_equal(20, foo.ex_squared)
+      end
+
+      def test_use_ruby_global_object
+        func = @runtime.evaluate("function(x) { return this.x2(x); }")
+        foo  = Foo.new
+        assert_equal(4, func.call_using(foo, 2))
+      end
+      
+      def test_proxies_roundtrip
+        @runtime["foo"] = foo = Foo.new
+        assert_same(foo, @runtime.evaluate("foo"))
+      end
+      
+      def test_proxies_classes
+        @runtime["Foo"] = Foo
+        assert_same(Foo, @runtime.evaluate("Foo"))
+      end
+      
+      def test_proxies_modules
+        @runtime["AModule"] = AModule
+        assert_same(AModule, @runtime.evaluate("AModule"))
+      end
+      
+      def test_proxies_hashes
+        @runtime["beatles"] = { "george" => "guitar" }
+        assert_equal("guitar", @runtime.evaluate("beatles['george']"))
+      end
+      
+      def test_getter_calls_0_arity_method
+        @runtime["foo"] = Foo.new
+        assert_js_equal(10, "foo.bar")
+      end
+      
+      def test_getter_calls_indexer
+        @runtime["foo"] = indexable = Indexable.new
+        indexable["bar"] = 10
+        
+        assert_js_equal(10, "foo.bar")
+      end
+      
+      def test_getter_returns_nil_for_unknown_properties
+        @runtime["foo"] = Foo.new
+        assert_js_equal(nil, "foo.quux")
+      end
+
+      def test_setter_calls_key=
+        @runtime["foo"] = foo = Foo.new
+        assert_js_equal(42, "foo.bar = 42")
+        assert_equal(42, foo.bar)
+      end
+      
+      def test_setter_calls_indexer
+        @runtime["foo"] = indexable = Indexable.new
+        assert_js_equal(42, "foo.monkey = 42")
+        assert_equal(42, indexable["monkey"])
+      end
+      
+      def test_calls_attr_reader
+        @runtime["foo"] = Foo.new
+        assert_js_equal(10, "foo.bar")
+      end
+      
+      def test_calls_1_arity_method
+        @runtime["foo"] = Foo.new
+        assert_js_equal(10, "foo.x2(5)")
+      end
+      
+      def test_calls_n_arity_method
+        @runtime["foo"] = Foo.new
+        assert_js_equal(10, "foo.add(4, 2, 2, 1, 1)")
+      end
+      
+      def test_calls_class_method
+        @runtime["Foo"] = Foo
+        assert_js_equal(Foo.bar, "Foo.bar()")
+      end
+      
+      def test_accesses_consts
+        @runtime["Foo"] = Foo
+        assert_same(Foo::Inner, @runtime.evaluate("Foo.Inner"))
+      end
+            
+      def test_can_create_new_instances_in_js
+        @runtime["AClass"] = AClass
+        foo = @runtime.evaluate("AClass.new()")
+        assert_kind_of(AClass, foo)
+      end
+      
+      def test_class_proxies_provide_a_ctor
+        @runtime["AClass"] = AClass
+        foo = @runtime.evaluate("new AClass()")
+        assert_kind_of(AClass, foo)
+        
+        bar = @runtime.evaluate("new AClass(1, 2, 3)")
+        assert_equal([1, 2, 3], bar.args)
+      end
+      
+      def test_dwims_blocks
+        @runtime["foo"] = Foo.new
+        assert_js_equal(4, "foo.xform(2, function(x) { return x * 2 })")
+      end
+      
+      def test_dwims_blocks_for_0_arity_methods
+        @runtime[:arr] = [1, 2, 3]
+        assert_js_equal([2, 4, 6], "arr.collect(function(x) { return x * 2 })")
+      end
+      
+      def test_scope_for_with
+        assert_js_equal(84, "with (rb) { b + b }", :b => 1, :rb => { "b" => 42 })
+      end
+      
+      def test_lambdas_for_with
+        assert_js_equal(84, "with (rb) { b(42) }", :rb => { "b" => lambda { |x| x * 2 } })
+      end
+      
+      class MethodForWith
+        def b(x); x * 2; end
+      end
+      
+      def test_method_for_with
+        assert_js_equal(84, "with (rb) { b(42) }", :rb => MethodForWith.new)
+      end
+
+      def test_raises_string_to_ruby
+        assert_raise(Johnson::Error) { @runtime.evaluate("throw 'my string';") }
+      end
+
+      def test_raises_object_to_ruby
+        assert_raise(Johnson::Error) { @runtime.evaluate("throw { bad: true };") }
+      end
+
+      def test_raises_exception_to_ruby
+        assert_raise(Johnson::Error) { @runtime.evaluate("undefinedValue();") }
+      end
+    end
+  end
+end

data/test/johnson/spidermonkey/ruby_land_proxy_test.rb

@@ -0,0 +1,240 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module SpiderMonkey
+    class RubyLandProxyTest < Johnson::TestCase
+      def setup
+        @runtime = Johnson::Runtime.new(Johnson::SpiderMonkey::Runtime)
+      end
+      
+      def test_constructing_a_proxy_directly_asplodes
+        assert_raise(Johnson::Error) { Johnson::SpiderMonkey::RubyLandProxy.new }
+      end
+      
+      def test_objects_get_wrapped_as_proxies
+        assert_kind_of(Johnson::SpiderMonkey::RubyLandProxy, @runtime.evaluate("x = {}"))
+        assert_kind_of(Johnson::SpiderMonkey::RubyLandProxy, @runtime.evaluate("new Object()"))
+      end
+      
+      def test_proxies_get_unwrapped_when_roundtripping
+        proxy = @runtime.evaluate("x = {}")
+        @runtime["y"] = proxy
+        assert(@runtime.evaluate("x === y"))
+      end
+
+      def test_reponds_to?
+        proxy = @runtime.evaluate("x = {}")
+        assert ! proxy.respond_to?(:foo)
+        assert ! proxy.respond_to?("foo")
+      end
+      
+      def test_array_indexable
+        proxy = @runtime.evaluate("var x = [1,2,3]; x")
+        assert_equal(1, proxy[0])
+        assert_equal(1, proxy['0'])
+
+        proxy[0] = 10
+        assert_js_equal(10, 'x[0]')
+      end
+      
+      def test_hash_indexable
+        proxy = @runtime.evaluate("var x = { 0: 1, 1: 2, 2: 3 }; x")
+        assert_equal(1, proxy[0])
+        assert_equal(1, proxy['0'])
+
+        proxy[0] = 10
+        assert_js_equal(10, 'x[0]')
+      end
+
+      def test_functions_get_wrapped_as_proxies
+        f = @runtime.evaluate("function() {}")
+        assert_kind_of(Johnson::SpiderMonkey::RubyLandProxy, f)
+        assert(f.function?)
+      end
+
+      def test_function?
+        f = @runtime.evaluate("function() {}")
+        assert_kind_of(Johnson::SpiderMonkey::RubyLandProxy, f)
+        assert(f.function?)
+
+        f = @runtime.evaluate("new Object()")
+        assert_kind_of(Johnson::SpiderMonkey::RubyLandProxy, f)
+        assert(!f.function?)
+      end
+      
+      def test_calling_non_functions_complains
+        assert_raise(RuntimeError) { @runtime.evaluate("new Object()").call }
+      end
+      
+      def test_functions_can_be_called
+        f = @runtime.evaluate("function() { return 42; }")
+        assert_equal(42, f.call)
+      end
+      
+      def test_functions_can_be_called_with_args
+        f = @runtime.evaluate("function(x) { return x * 2; }")
+        assert_equal(84, f.call(42))
+      end
+      
+      def test_functions_can_be_used_as_procs
+        f = @runtime.evaluate("function(x) { return x * 2; }")
+        a = [1, 2, 3]
+        
+        assert_equal([2, 4, 6], a.collect(&f))
+      end
+      
+      def test_function_proxies_are_called_with_a_global_this
+        f = @runtime.evaluate("x = 42; function() { return this.x; }")
+        assert_equal(42, f.call)
+      end
+      
+      def test_can_be_indexed_by_string
+        proxy = @runtime.evaluate("x = { foo: 42 }")
+        assert_kind_of(Johnson::SpiderMonkey::RubyLandProxy, proxy)
+        
+        assert_equal(42, proxy["foo"])
+        
+        proxy["foo"] = 99
+        proxy["bar"] = 42
+        
+        assert_js_equal(99, "x.foo")
+        assert_equal(99, proxy["foo"])
+        assert_equal(42, proxy["bar"])
+      end
+      
+      def test_multilevel_indexing_works
+        proxy = @runtime.evaluate("x = { foo: { bar: 42 , baz: function() { return 42 } } }")
+        assert_equal(42, proxy["foo"]["bar"])
+        assert_equal(42, proxy["foo"]["baz"].call)
+      end
+      
+      def test_respond_to_works
+        proxy = @runtime.evaluate("x = { foo: 42 }")
+        assert(!proxy.respond_to?(:bar))
+        assert(proxy.respond_to?(:foo))
+      end
+      
+      def test_respond_to_always_returns_true_for_assignment
+        proxy = @runtime.evaluate("x = {}")
+        assert(proxy.respond_to?(:bar=))
+      end
+      
+      def test_accessor
+        proxy = @runtime.evaluate("x = { foo: 42 }")
+        assert_equal(42, proxy.foo)
+      end
+      
+      def test_mutator
+        proxy = @runtime.evaluate("x = {}")
+        proxy.foo = 42
+        
+        assert_js_equal(42, "x.foo")
+        assert_equal(42, proxy.foo)
+      end
+      
+      def test_method_with_no_arguments
+        proxy = @runtime.evaluate("x = { foo: function() { return 42 } }")
+        assert_equal(42, proxy.foo)
+      end
+      
+      def test_method_with_one_argument
+        proxy = @runtime.evaluate("f = { f: function(x) { return x * 2 } }")
+        assert_equal(84, proxy.f(42))
+      end
+      
+      def test_method_with_multiple_arguments
+        proxy = @runtime.evaluate("x = { add: function(x, y) { return x + y } }")
+        assert_equal(42, proxy.add(40, 2))
+      end
+      
+      def test_supports_each_on_arrays
+        proxy = @runtime.evaluate("[1, 2, 3]")
+        values = []
+        
+        proxy.each { |n| values << n }
+        assert_equal([1, 2, 3], values)
+      end
+      
+      def test_supports_each_on_things_that_arent_arrays
+        proxy = @runtime.evaluate("x = { foo: 'fooval', bar: 'barval' }; x[0] = 42; x")
+        values = {}
+        
+        proxy.each { |k, v| values[k] = v }
+        assert_equal({ 'foo' => 'fooval', 'bar' => 'barval', 0 => 42 }, values)
+      end
+      
+      def test_each_passes_an_exception
+        proxy = @runtime.evaluate("x = { foo: 'fooval', bar: 'barval' }; x[0] = 42; x")
+        values = {}
+        
+        assert_raise(RuntimeError) do
+          proxy.each do |k, v|
+            values[k] = v
+            raise "splat" if values.keys.size == 2
+          end
+        end
+        assert_equal({ 'foo' => 'fooval', 'bar' => 'barval' }, values)
+      end
+      
+      def test_is_enumerable
+        proxy = @runtime.evaluate("[1, 2, 3]")
+        assert_kind_of(Enumerable, proxy)
+        
+        assert_equal([2, 4, 6], proxy.collect { |n| n * 2 })
+      end
+      
+      def test_has_a_length
+        proxy = @runtime.evaluate("[1, 2, 3]")
+        assert_equal(3, proxy.length)
+      end
+      
+      def test_length_is_aliased_as_size
+        proxy = @runtime.evaluate("[1, 2, 3]")
+        assert_equal(3, proxy.size)
+      end
+      
+      def test_length_for_arrays_ignores_non_numeric_properties
+        proxy = @runtime.evaluate("x = [1, 2, 3]; x['foo'] = 'bar'; x")
+        assert_equal(3, proxy.length)
+      end
+      
+      def test_length_for_objects_includes_all_properties
+        proxy = @runtime.evaluate("x = { foo: 'foo', bar: 'bar', 0: 42 }")
+        assert_equal(3, proxy.length)
+      end
+
+      def test_raises_in_js
+        err = RuntimeError.new("an exception")
+        asplode = lambda { raise err }
+        assert_js_equal(err, "x = null; try { foo(); } catch(ex) { x = ex; }; x", :foo => asplode)
+      end
+      
+      def test_array_multiple_assignment
+        a = @runtime.evaluate("[1,2,3]")
+        x, y, z = a
+        
+        assert_equal(1, x)
+        assert_equal(2, y)
+        assert_equal(3, z)
+      end
+
+      # FIXME: If you uncomment this test, we get this error:
+      #
+      # JS API usage error: the address passed to JS_AddNamedRoot currently holds an
+      # invalid jsval.  This is usually caused by a missing call to JS_RemoveRoot.
+      # The root's name is "ruby_land_proxy.c[210]:native_call: proxy_value".
+      # Assertion failure: root_points_to_gcArenaList, at jsgc.c:2618
+      # 
+      # WTF?
+      #
+      # -Aaron
+      #
+      #def test_throwing_in_js_goes_to_ruby
+      #  func = @runtime.evaluate('function () { throw "foo"; }')
+      #  assert_raise(Johnson::Error) {
+      #    func.call
+      #  }
+      #end
+    end
+  end
+end