therubyracer-discourse 0.12.0

data/spec/c/template_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe V8::C::Template do
+
+  describe V8::C::FunctionTemplate do
+    it "can be created with no arguments" do
+      t = V8::C::FunctionTemplate::New()
+      t.GetFunction().Call(@cxt.Global(),[]).StrictEquals(@cxt.Global()).should be_true
+    end
+
+    it "can be created with a callback" do
+      receiver = V8::C::Object::New()
+      f = nil
+      callback = lambda do |arguments|
+        arguments.Length().should be(2)
+        arguments[0].Utf8Value().should eql 'one'
+        arguments[1].Utf8Value().should eql 'two'
+        arguments.Callee().StrictEquals(f).should be_true
+        arguments.This().StrictEquals(receiver).should be_true
+        arguments.Holder().StrictEquals(receiver).should be_true
+        arguments.IsConstructCall().should be_false
+        arguments.Data().Value().should be(42)
+        V8::C::String::New("result")
+      end
+      t = V8::C::FunctionTemplate::New(callback, V8::C::External::New(42))
+      f = t.GetFunction()
+      f.Call(receiver, [V8::C::String::New('one'), V8::C::String::New('two')]).Utf8Value().should eql "result"
+    end
+  end
+end

data/spec/c/trycatch_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe V8::C::External do
+
+  it "can catch javascript exceptions" do
+    V8::C::V8::SetCaptureStackTraceForUncaughtExceptions(true, 99, V8::C::StackTrace::kDetailed)
+    V8::C::TryCatch() do |trycatch|
+      source = V8::C::String::New(<<-JS)
+      function one() {
+        two()
+      }
+      function two() {
+        three()
+      }
+      function three() {
+        boom()
+      }
+      function boom() {
+        throw new Error('boom!')
+      }
+      eval('one()')
+      JS
+      filename = V8::C::String::New("<eval>")
+      script = V8::C::Script::New(source, filename)
+      result = script.Run()
+      trycatch.HasCaught().should be_true
+      trycatch.CanContinue().should be_true
+      exception = trycatch.Exception()
+      exception.should_not be_nil
+      exception.IsNativeError().should be_true
+      trycatch.StackTrace().Utf8Value().should match /boom.*three.*two.*one/m
+      message = trycatch.Message();
+      message.should_not be_nil
+      message.Get().Utf8Value().should eql "Uncaught Error: boom!"
+      message.GetSourceLine().Utf8Value().should eql "        throw new Error('boom!')"
+      message.GetScriptResourceName().Utf8Value().should eql "<eval>"
+      message.GetLineNumber().should eql 11
+      stack = message.GetStackTrace()
+      stack.should_not be_nil
+      stack.GetFrameCount().should eql 6
+      frame = stack.GetFrame(0)
+      frame.GetLineNumber().should eql 11
+      frame.GetColumn().should eql 15
+      frame.GetScriptName().Utf8Value().should eql "<eval>"
+      frame.GetScriptNameOrSourceURL().Utf8Value().should eql "<eval>"
+      frame.IsEval().should be_false
+      stack.GetFrame(4).IsEval().should be_true
+      frame.IsConstructor().should be_false
+    end
+  end
+end

data/spec/mem/blunt_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe "A Very blunt test to make sure that we aren't doing stupid leaks", :memory => true do
+  before do
+    if Object.const_defined?(:RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+      pending 'need to figure out how to do memory sanity checks on rbx'
+    end
+    #allocate a single context to make sure that v8 loads its snapshot and
+    #we pay the overhead.
+    V8::Context.new
+    @start_memory = process_memory
+    GC.stress = true
+  end
+
+  after do
+    GC.stress = false
+  end
+  it "won't increase process memory by more than 50% no matter how many contexts we create" do
+    500.times do
+       V8::Context.new
+       run_v8_gc
+    end
+    process_memory.should <= @start_memory * 1.5
+  end
+
+  it "can eval simple value passing statements repeatedly without significantly increasing memory" do
+    V8::C::Locker() do
+      cxt = V8::Context.new
+      500.times do
+        cxt.eval('7 * 6')
+        run_v8_gc
+      end
+    end
+      process_memory.should <= @start_memory * 1.1
+  end
+
+  def process_memory
+    /\w*[ ]*#{Process.pid}[ ]*([.,\d]*)[ ]*([.,\d]*)[ ]*([\d]*)[ ]*([\d]*)/.match(`ps aux`)[4].to_i
+  end
+
+end
+

data/spec/redjs_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'redjs/load_specs'
+module RedJS
+  Context = V8::Context
+  Error = V8::Error
+end
+describe V8::Context do
+  pending "not ready for prime-time"
+  #it_behaves_like 'RedJS::Context'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,45 @@
+require 'v8'
+
+def run_v8_gc
+  V8::C::V8::LowMemoryNotification()
+  while !V8::C::V8::IdleNotification() do
+  end
+end
+
+def rputs(msg)
+  puts "<pre>#{ERB::Util.h(msg)}</pre>"
+  $stdout.flush
+end
+
+module ExplicitScoper;end
+module Autoscope
+  def instance_eval(*args, &block)
+    return super unless low_level_c_spec? && !explicitly_defines_scope?
+    V8::C::Locker() do
+      V8::C::HandleScope() do
+        @cxt = V8::C::Context::New()
+        begin
+          @cxt.Enter()
+          super(*args, &block)
+        ensure
+          @cxt.Exit()
+        end
+      end
+    end
+  end
+
+  def low_level_c_spec?
+    return false unless described_class
+    described_class.name =~ /^V8::C::/
+  end
+
+  def explicitly_defines_scope?
+    is_a?(ExplicitScoper)
+  end
+end
+
+RSpec.configure do |c|
+  c.before(:each) do
+    extend Autoscope
+  end
+end

data/spec/threading_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe "Timeouts" do
+  it "allows for timeout on context" do
+    ctx = V8::Context.new(:timeout => 10)
+    lambda {ctx.eval("while(true){}")}.should(raise_error)
+
+    # context should not be bust after it exploded once
+    ctx["x"] = 1;
+    ctx.eval("x=2;")
+    ctx["x"].should == 2
+  end
+end
+
+describe "using v8 from multiple threads", :threads => true do
+
+  it "creates contexts from within threads" do
+    10.times.collect do
+      Thread.new do
+        V8::Context.new
+      end
+    end.each {|t| t.join}
+    V8::Context.new
+  end
+
+  it "executes codes on multiple threads simultaneously" do
+    5.times.collect{V8::Context.new}.collect do |ctx|
+      Thread.new do
+        ctx['x'] = 99
+        while ctx['x'] > 0
+          ctx.eval 'for (i=10000;i;i--){};--x'
+        end
+      end
+    end.each {|t| t.join}
+  end
+
+  it "can access the current thread id" do
+    V8::C::Locker() do
+      V8::C::V8::GetCurrentThreadId().should_not be_nil
+    end
+  end
+
+  it "can pre-empt a running JavaScript thread" do
+    pending "need to release the GIL while executing V8 code"
+    begin
+      V8::C::Locker::StartPreemption(2)
+      thread_id = nil
+      Thread.new do
+        loop until thread_id
+        puts "thread id: #{thread_id}"
+        V8::C::V8::TerminateExecution(thread_id)
+      end
+      Thread.new do
+        V8::C::Locker() do
+          thread_id = V8::C::V8::GetCurrentThreadId()
+          V8::Context.new {|cxt| cxt.eval('while (true) {}')}
+        end
+      end
+      V8::C::V8::TerminateExecution(thread_id)
+    ensure
+      V8::C::Locker::StopPreemption()
+    end
+  end
+end

data/spec/v8/context_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe V8::Context do
+  it "can be disposed of" do
+    cxt = V8::Context.new
+    cxt.enter do
+      cxt['object'] = V8::Object.new
+    end
+    cxt.dispose()
+
+    lambda {cxt.eval('1 + 1')}.should raise_error
+    lambda {cxt['object']}.should raise_error
+  end
+
+  it "can be disposed of any number of times" do
+    cxt = V8::Context.new
+    10.times {cxt.dispose()}
+  end
+end

data/spec/v8/conversion_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'bigdecimal'
+describe V8::Conversion do
+
+  let(:cxt) { V8::Context.new }
+
+  it "can embed BigDecimal values" do
+    cxt['big'] = BigDecimal.new('1.1')
+    cxt['big'].should eql BigDecimal.new('1.1')
+  end
+
+  it "doesn't try to use V8::Conversion::Class::* as root objects" do
+    klass = Class.new do
+      class << self
+        def test
+          Set.new
+        end
+      end
+    end
+
+    klass.test.should be_instance_of(::Set)
+  end
+
+  context "::Fixnum" do
+    context "for 32-bit numbers" do
+      it "should convert positive integer" do
+        cxt['fixnum_a'] = 123
+        cxt['fixnum_a'].should == 123
+        cxt['fixnum_a'].should be_instance_of(Fixnum)
+      end
+
+      it "should convert negative integer" do
+        cxt['fixnum_b'] = -123
+        cxt['fixnum_b'].should == -123
+        cxt['fixnum_b'].should be_instance_of(Fixnum)
+      end
+    end
+
+    context "for 64-bit numbers" do
+      it "should convert positive integer" do
+        cxt['fixnum_c'] = 0x100000000
+        cxt['fixnum_c'].should == 0x100000000
+      end
+
+      it "should convert negative integer" do
+        cxt['fixnum_d'] = -0x100000000
+        cxt['fixnum_d'].should == -0x100000000
+      end
+    end
+
+  end
+end

data/spec/v8/error_spec.rb

@@ -0,0 +1,165 @@
+require 'spec_helper'
+
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe V8::Error do
+
+  before do
+    @cxt = V8::Context.new
+    @cxt['one'] = lambda do
+      @cxt.eval('two()', 'one.js')
+    end
+    @cxt['two'] = lambda do
+      @cxt.eval('three()', 'two.js')
+    end
+  end
+
+  it "captures a message without over nesting when the error is an error" do
+    throw! do |e|
+      e.message.should == "BOOM!"
+    end
+  end
+
+  it "captures the js message without over nesting when the error is a normal object" do
+    throw!('{foo: "bar"}') do |e|
+      e.message.should == "[object Object]"
+    end
+    throw!('{message: "bar"}') do |e|
+      e.message.should == "bar"
+    end
+  end
+
+  it "captures a thrown value as the message" do
+    throw!('"BOOM!"') do |e|
+      e.message.should == "BOOM!"
+    end
+    throw!('6') do |e|
+      e.message.should == '6'
+    end
+  end
+
+  it "has a reference to the root javascript cause" do
+    throw!('"I am a String"') do |e|
+      e.should_not be_in_ruby
+      e.should be_in_javascript
+      e.value['message'].should == "I am a String"
+    end
+  end
+
+  it "has a reference to the root ruby cause if one exists" do
+    StandardError.new("BOOM!").tap do |bomb|
+      @cxt['boom'] = lambda do
+        raise bomb
+      end
+      lambda {
+        @cxt.eval('boom()', 'boom.js')
+      }.should(raise_error do |raised|
+        raised.should be_in_ruby
+        raised.should_not be_in_javascript
+        raised.root_cause.should be(bomb)
+      end)
+    end
+  end
+
+  describe "backtrace" do
+    it "is mixed with ruby and javascript" do
+      throw! do |e|
+        e.backtrace.first.should == "at three.js:1:7"
+        e.backtrace[1].should =~ /error_spec.rb/
+        e.backtrace[2].should == "at two.js:1:1"
+        e.backtrace[3].should =~ /error_spec.rb/
+        e.backtrace[4].should == "at one.js:1:1"
+      end
+    end
+
+    it "can be set to show only ruby frames" do
+      throw! do |e|
+        e.backtrace(:ruby).each do |frame|
+          frame.should =~ /(\.rb|):\d+/
+        end
+      end
+    end
+
+    it "can be set to show only javascript frames" do
+      throw! do |e|
+        e.backtrace(:javascript).each do |frame|
+          frame.should =~ /\.js:\d:\d/
+        end
+      end
+    end
+
+    it "includes a mystery marker when the original frame is unavailable because what got thrown wasn't an error" do
+      throw!("6") do |e|
+        e.backtrace.first.should == 'at three.js:1:1'
+      end
+    end
+
+    it "has a source name and line number when there is a javascript SyntaxError" do
+      lambda do
+        @cxt.eval(<<-INVALID, 'source.js')
+"this line is okay";
+"this line has a syntax error because it ends with a colon":
+"this line is also okay";
+"how do I find out that line 2 has the syntax error?";
+INVALID
+      end.should raise_error(V8::JSError) {|error|
+        error.message.should eql 'Unexpected token : at source.js:2:61'
+      }
+    end
+
+    it "can start with ruby at the bottom" do
+      @cxt['boom'] = lambda do
+        raise StandardError, "Bif!"
+      end
+      lambda {
+        @cxt.eval('boom()', "boom.js")
+      }.should(raise_error {|e|
+        e.backtrace.first.should =~ /error_spec\.rb/
+        e.backtrace[1].should =~ /boom.js/
+      })
+    end
+  end
+
+
+  def throw!(js = "new Error('BOOM!')", &block)
+    @cxt['three'] = lambda do
+      @cxt.eval("throw #{js}", 'three.js')
+    end
+    lambda do
+      @cxt['one'].call()
+    end.should(raise_error(V8::JSError, &block))
+  end
+end
+
+
+# describe V8::Error do
+#   describe "A ruby exception thrown inside JavaScript" do
+#     before do
+#       @error = StandardError.new('potato')
+#       begin
+#         V8::Context.new do |cxt|
+#           cxt['one'] = lambda do
+#             cxt.eval('two()', 'one.js')
+#           end
+#           cxt['two'] = lambda do
+#             cxt.eval('three()', 'two.js')
+#           end
+#           cxt['three'] = lambda do
+#             raise @error
+#           end
+#           cxt.eval('one()')
+#         end
+#       rescue StandardError => e
+#         @thrown = e
+#       end
+#     end
+#     it "is raised up through the call stack" do
+#       @thrown.should be(@error)
+#     end
+#
+#     it "shows both the javascript and the ruby callframes" do
+#       puts @error.backtrace.join('<br/>')
+#     end
+#
+#   end
+# end