jbarnette-johnson 1.0.0.200806240111

data/test/johnson/spidermonkey/ruby_land_proxy_test.rb

@@ -0,0 +1,225 @@
+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_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
+
+      # 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

data/test/johnson/spidermonkey/runtime_test.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+module Johnson
+  module SpiderMonkey
+    class RuntimeTest < Johnson::TestCase
+      def setup
+        @runtime = Johnson::SpiderMonkey::Runtime.new
+      end
+      
+      def test_can_create_more_than_one_without_barfing
+        assert_nothing_raised {
+          Johnson::SpiderMonkey::Runtime.new
+        }
+      end
+    end
+  end
+end

data/test/johnson/version_test.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../helper"))
+
+module Johnson
+  class VersionTest < Johnson::TestCase
+    def test_has_a_version
+      assert_not_nil(Johnson::VERSION)
+    end
+  
+    def test_has_a_spidermonkey_version
+      assert_not_nil(Johnson::SpiderMonkey::VERSION)
+    end
+  end
+end

data/test/johnson/visitors/dot_visitor_test.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+class DotVisitorTest < Test::Unit::TestCase
+  def test_var_foo
+    dot = Johnson.parse('var foo;').to_dot
+    assert_equal(3, dot.nodes.length)
+    assert_equal(2, dot.links.length)
+  end
+
+  def test_for
+    dot = Johnson.parse('for(var x = 0; x < 10; x++) { }').to_dot
+    assert_equal(12, dot.nodes.length)
+    assert_equal(11, dot.links.length)
+  end
+
+  def test_for_in
+    dot = Johnson.parse('for(var x in johnson(1,2,"asdf")) { }').to_dot
+    assert_equal(11, dot.nodes.length)
+    assert_equal(10, dot.links.length)
+  end
+
+  def test_try
+    dot = Johnson.parse('try { var x = 10; } finally { var x = 20; }').to_dot
+    assert_equal(12, dot.nodes.length)
+    assert_equal(11, dot.links.length)
+  end
+
+  def test_try_catch
+    dot = Johnson.parse('try { var x = 10; } catch(a) { var x = 20; x++; }').to_dot
+    assert_equal(16, dot.nodes.length)
+    assert_equal(15, dot.links.length)
+  end
+
+  def test_function
+    dot = Johnson.parse("var foo = function(a,b) { }").to_dot
+    assert_equal(6, dot.nodes.length)
+    assert_equal(5, dot.links.length)
+  end
+end

data/test/johnson/visitors/enumerating_visitor_test.rb

@@ -0,0 +1,12 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "/../../helper"))
+
+class EnumeratingVisitorTest < Test::Unit::TestCase
+  def test_for
+    ast = Johnson.parse('for(var x = 0; x < 10; x++) { }')
+    counter = 0
+    ast.each do |node|
+      counter += 1
+    end
+    assert_equal(12, counter)
+  end
+end

data/test/johnson_test.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "helper"))
+
+class JohnsonTest < Test::Unit::TestCase
+  def test_shortcut_evaluate
+    assert_equal(4, Johnson.evaluate("2 + 2"))
+  end
+  
+  def test_can_provide_context_vars_to_evaluate
+    assert_equal(4, Johnson.evaluate("2 + foo", :foo => 2))
+  end
+  
+  def test_evaluate_uses_a_new_runtime_each_time
+    assert_equal(4, Johnson.evaluate("foo", :foo => 4))
+    assert_raise(Johnson::Error) { Johnson.evaluate("foo") }
+  end
+end

data/test/jquery_units/test.js

@@ -0,0 +1,27 @@
+// Init
+Johnson.require("johnson/browser");
+Johnson.require("johnson/browser/jquery");
+
+Johnson.waitForThreads = function() {
+  // FIXME: This sucks ass
+  Ruby.eval("(Thread.list - [Thread.main]).each {|t| t.join}");
+};
+
+window.location = "file://" + Ruby.File.expand_path(Ruby.Dir.pwd()) + "/test/assets/jquery_test.html";
+Ruby.eval("(Thread.list - [Thread.main]).each {|t| t.join}");
+
+// Load the test runner
+Johnson.require("test/jquery_units/test_helper.js");
+
+Johnson.require("test/jquery_units/units/core.js");
+// // Load the tests
+// load(
+//     "test/unit/core.js",
+//     "test/unit/selector.js",
+//     "test/unit/event.js"
+//     //"test/unit/fx.js",
+//     //"test/unit/ajax.js"
+// );
+
+// Display the results
+results();

data/test/jquery_units/test_helper.js

@@ -0,0 +1,197 @@
+function test(name, fn){
+	expected = -1;
+	numTests = 0;
+	reset();
+	
+	fn();
+	
+	if ( expected != -1 && expected != numTests )
+		log( false, "Wrong number of tests run. " + numTests + " ran, expected " + expected );
+}
+
+var orig = document.getElementById('main').innerHTML;
+
+/**
+ * Resets the test setup. Useful for tests that modify the DOM.
+ */
+function reset() {
+	document.getElementById('main').innerHTML = orig;
+}
+
+var currentModule = "";
+
+// call on start of module test to prepend name to all tests
+function module(moduleName) {
+	currentModule = moduleName;
+}
+
+var expected = -1;
+
+/**
+ * Specify the number of expected assertions to gurantee that failed test (no assertions are run at all) don't slip through.
+ */
+function expect(asserts) {
+	expected = asserts;
+}
+
+/**
+ * Asserts true.
+ * @example ok( $("a").size() > 5, "There must be at least 5 anchors" );
+ */
+function ok(a, msg) {
+	log( !!a, msg );
+}
+
+/**
+ * Asserts that two arrays are the same
+ */
+function isSet(a, b, msg) {
+	var ret = true;
+	if ( a && b && a.length != undefined && a.length == b.length ) {
+		for ( var i = 0; i < a.length; i++ ) {
+			if ( a[i] != b[i] )
+				ret = false;
+		}
+	} else
+		ret = false;
+	if ( !ret )
+		log( ret, msg + " expected: " + serialArray(b) + " result: " + serialArray(a) );
+	else 
+		log( ret, msg );
+}
+
+/**
+ * Asserts that two objects are equivalent
+ */
+function isObj(a, b, msg) {
+	var ret = true;
+	
+	if ( a && b ) {
+		for ( var i in a )
+			if ( a[i] != b[i] )
+				ret = false;
+
+		for ( i in b )
+			if ( a[i] != b[i] )
+				ret = false;
+	} else
+		ret = false;
+
+    log( ret, msg );
+}
+
+function serialArray( a ) {
+	var r = [];
+	
+	if ( a && a.length )
+        for ( var i = 0; i < a.length; i++ ) {
+            var str = a[i] ? a[i].nodeName : "";
+            if ( str ) {
+                str = str.toLowerCase();
+                if ( a[i].id )
+                    str += "#" + a[i].id;
+            } else
+                str = a[i];
+            r.push( str );
+        }
+
+	return "[ " + r.join(", ") + " ]"
+}
+
+/**
+ * Returns an array of elements with the given IDs, eg.
+ * @example q("main", "foo", "bar")
+ * @result [<div id="main">, <span id="foo">, <input id="bar">]
+ */
+function q() {
+	var r = [];
+	for ( var i = 0; i < arguments.length; i++ )
+		r.push( document.getElementById( arguments[i] ) );
+	return r;
+}
+
+/**
+ * Asserts that a select matches the given IDs
+ * @example t("Check for something", "//[a]", ["foo", "baar"]);
+ * @result returns true if "//[a]" return two elements with the IDs 'foo' and 'baar'
+ */
+function t(a,b,c) {
+	var f = jQuery(b);
+	var s = "";
+	for ( var i = 0; i < f.length; i++ )
+		s += (s && ",") + '"' + f[i].id + '"';
+	isSet(f, q.apply(q,c), a + " (" + b + ")");
+}
+
+/**
+ * Checks that the first two arguments are equal, with an optional message.
+ * Prints out both expected and actual values on failure.
+ *
+ * Prefered to ok( expected == actual, message )
+ *
+ * @example equals( "Expected 2 characters.", v.formatMessage("Expected {0} characters.", 2) );
+ *
+ * @param Object expected
+ * @param Object actual
+ * @param String message (optional)
+ */
+function equals(expected, actual, message) {
+	var result = expected == actual;
+	message = message || (result ? "okay" : "failed");
+	log( result, result ? message + ": " + expected : message + " expected: " + expected + " actual: " + actual );
+}
+
+var numTests = 0, total = 0, pass = 0, fail = 0;
+
+function log(state, msg){
+	print( (state ? "PASS" : "FAIL") + " (" + (++total) + ") " +
+		(currentModule ? "[" + currentModule + "] " : "") + msg );
+		
+	numTests++;
+
+	if ( state )
+		pass++;
+	else
+		fail++;
+}
+
+function results(){
+	print( pass + " Passed, " + fail + " Failed" );
+}
+
+function start(){}
+function stop(){}
+
+/**
+ * Trigger an event on an element.
+ *
+ * @example triggerEvent( document.body, "click" );
+ *
+ * @param DOMElement elem
+ * @param String type
+ */
+function triggerEvent( elem, type, event ) {
+/*
+	if ( jQuery.browser.mozilla || jQuery.browser.opera ) {
+		event = document.createEvent("MouseEvents");
+		event.initMouseEvent(type, true, true, elem.ownerDocument.defaultView,
+			0, 0, 0, 0, 0, false, false, false, false, 0, null);
+		elem.dispatchEvent( event );
+	} else if ( jQuery.browser.msie ) {
+		elem.fireEvent("on"+type);
+	}
+*/
+}
+
+/**
+ * Add random number to url to stop IE from caching
+ *
+ * @example url("data/test.html")
+ * @result "data/test.html?10538358428943"
+ *
+ * @example url("data/test.php?foo=bar")
+ * @result "data/test.php?foo=bar&10538358345554"
+ */
+function url(value) {
+	return value + (/\?/.test(value) ? "&" : "?") + new Date().getTime() + "" + parseInt(Math.random()*100000);
+}