opal-browser 0.1.0.beta1 → 0.3.1

data/spec/{dom/event_spec.rb → event_spec.rb}

@@ -1,6 +1,7 @@
 require 'spec_helper'
+require 'browser/event'
 
-describe Browser::DOM::Event do
+describe Browser::Event do
   html <<-HTML
     <div id="event-spec">
       u wot m8
@@ -16,13 +17,13 @@ describe Browser::DOM::Event do
         count += 1
       end
 
-      count.should == 0
+      expect(count).to eq(0)
       elem.trigger :click
-      count.should == 1
+      expect(count).to eq(1)
       elem.trigger :click
-      count.should == 2
+      expect(count).to eq(2)
       elem.trigger 'mouse:down'
-      count.should == 2
+      expect(count).to eq(2)
     end
 
     it "listens for custom events" do
@@ -33,46 +34,53 @@ describe Browser::DOM::Event do
         count += 1
       end
 
-      count.should == 0
+      expect(count).to eq(0)
       elem.trigger :huehue
-      count.should == 1
+      expect(count).to eq(1)
       elem.trigger :huehue
-      count.should == 2
+      expect(count).to eq(2)
     end
 
-    async "passes an event to the handler" do
+    it "passes an event to the handler" do
       elem = $document["event-spec"]
 
+      promise = Browser::Promise.new
+
       elem.on :click do |event|
-        run_async {
-          event.should be_kind_of Browser::DOM::Event
-        }
+        expect(event).to be_a(Browser::Event)
+        promise.resolve
       end
 
       elem.trigger :click
+
+      promise.for_rspec
     end
 
-    async "passes additional arguments to the handler" do
+    it "passes additional arguments to the handler" do
       elem = $document["event-spec"]
 
+      promise = Browser::Promise.new
+
       elem.on :bazinga do |event, foo, bar, baz|
-        run_async {
-          foo.should == 1
-          bar.should == 2
-          baz.should == 3
-        }
+        expect(foo).to eq(1)
+        expect(bar).to eq(2)
+        expect(baz).to eq(3)
+        promise.resolve
       end
 
       elem.trigger :bazinga, 1, 2, 3
+
+      promise.for_rspec
     end
 
-    async "works with deferred elements" do
+    it "works with delegated events" do
       elem = $document["event-spec"]
 
+      promise = Browser::Promise.new
+
       elem.on :bazinga, 'span.nami' do
-        run_async {
-          true.should be_truthy
-        }
+        expect(true).to be_truthy
+        promise.resolve
       end
 
       elem.add_child DOM { span.nami }
@@ -80,6 +88,27 @@ describe Browser::DOM::Event do
       after 0.01 do
         elem.first_element_child.trigger :bazinga
       end
+
+      promise.for_rspec
+    end
+  end
+
+  describe "#one" do
+    it "fires once, passes arguments, works with custom events" do
+      count = 0
+      elem  = $document["event-spec"]
+
+      elem.one :testone do |event, a, b, c|
+        count += a + b*c
+      end
+
+      expect(count).to eq(0)
+      elem.trigger :testone, 1, 2, 3
+      expect(count).to eq(7)
+      elem.trigger :testone, 2, 3, 4
+      expect(count).to eq(7)
+      elem.trigger :testone, 3, 4, 5
+      expect(count).to eq(7)
     end
   end
 
@@ -97,11 +126,11 @@ describe Browser::DOM::Event do
       end
 
       elem.trigger :click
-      count.should == 2
+      expect(count).to eq(2)
 
       elem.off :click
       elem.trigger :click
-      count.should == 2
+      expect(count).to eq(2)
     end
 
     it "removes only the passed handler" do
@@ -117,11 +146,11 @@ describe Browser::DOM::Event do
       end
 
       elem.trigger :click
-      count.should == 2
+      expect(count).to eq(2)
 
       cb.off
       elem.trigger :click
-      count.should == 3
+      expect(count).to eq(3)
     end
   end
 end

data/spec/history_spec.rb

@@ -4,45 +4,58 @@ require 'browser/history'
 describe Browser::History do
   describe '#current' do
     it 'should return the current location' do
-      $window.history.current.should == '/'
+      expect($window.history.current).to eq('/')
     end
   end
 
   describe '#push' do
     it 'should change location' do
-      $window.history.current.should == '/'
+      expect($window.history.current).to eq('/')
       $window.history.push('/lol')
-      $window.history.current.should == '/lol'
+      expect($window.history.current).to eq('/lol')
       $window.history.push('/')
-      $window.history.current.should == '/'
+      expect($window.history.current).to eq('/')
     end
   end
 
   describe '#back' do
-    async 'should go back once' do
-      $window.history.current.should == '/'
+    it 'should go back once' do
+      expect($window.history.current).to eq('/')
       $window.history.push('/wut')
-      $window.history.current.should == '/wut'
+      expect($window.history.current).to eq('/wut')
 
-      $window.on 'pop:state' do |e|
-        run_async {
-          $window.history.current.should == '/'
-        }
+      promise = Browser::Promise.new
 
-        e.off
+      $window.one 'pop:state' do |e|
+        expect($window.history.current).to eq('/')
+        promise.resolve
       end
 
       $window.history.back
+      promise.for_rspec
     end
   end
 
   describe '#state' do
     it 'gets the right state' do
-      $window.history.push('/wut', 42)
-      $window.history.state.should == 42
-      $window.history.push('/omg', 23)
-      $window.history.state.should == 23
-      $window.history.back(2)
+      # XX: The previous test creates a race condition with this one.
+      # Adding a delay fixes it.
+      promise = Browser::Promise.new
+
+      after 0.05 do
+        $window.history.push('/wut', 42)
+        $window.history.state.should eq(42)
+        $window.history.push('/omg', 23)
+        $window.history.state.should eq(23)
+
+        $window.one 'pop:state' do |e|
+          expect(true).to eq(true)
+          promise.resolve
+        end
+
+        $window.history.back(2)
+      end
+      promise.for_rspec
     end
-  end
-end
+  end if Browser.supports? 'History.state'
+end if Browser::History.supported?

data/spec/http_spec.rb

@@ -1,87 +1,76 @@
+require 'spec_helper'
 require 'browser/http'
 
 describe Browser::HTTP do
-  let :path do
-    '/http'
-  end
+  let(:path) { '/http' }
+  let(:path_file) { '/http-file' }
 
   describe '.get' do
-    async 'fetches a path' do
+    it 'fetches a path' do
       Browser::HTTP.get(path).then {|res|
-        run_async {
-          res.text.should == 'lol'
-        }
+        expect(res.text).to eq('lol')
       }.rescue {
-        run_async {
-          fail
-        }
+        fail
       }
     end
   end
 
   describe '.get!' do
     it 'fetches a path' do
-      Browser::HTTP.get!(path).text.should == 'lol'
+      expect(Browser::HTTP.get!(path).text).to eq('lol')
     end
   end
 
   describe '.post' do
-    async 'sends parameters properly' do
+    it 'sends parameters properly' do
       Browser::HTTP.post(path, lol: 'wut').then {|res|
-        run_async {
-          res.text.should == 'ok'
-        }
+        expect(res.text).to eq('ok')
       }.rescue {
-        run_async {
-          fail
-        }
+        fail
       }
     end
   end
 
   describe '.post!' do
     it 'sends parameters properly' do
-      Browser::HTTP.post!(path, lol: 'wut').text.should == 'ok'
+      expect(Browser::HTTP.post!(path, lol: 'wut').text).to eq('ok')
+    end
+
+    it 'sends files properly' do
+      file = Browser::File.create(["content"], "yay.txt", type: "text/plain")
+      expect(Browser::HTTP.post!(path_file, lol: 'wut', file: file).text).to eq('ok')
     end
   end
 
   describe '.put' do
-    async 'sends parameters properly' do
+    it 'sends parameters properly' do
       Browser::HTTP.put(path, lol: 'wut').then {|res|
-        run_async {
-          res.text.should == 'ok'
-        }
+        expect(res.text).to eq('ok')
       }.rescue {
-        run_async {
-          fail
-        }
+        fail
       }
     end
   end
 
   describe '.put!' do
     it 'sends parameters properly' do
-      Browser::HTTP.put!(path, lol: 'wut').text.should == 'ok'
+      expect(Browser::HTTP.put!(path, lol: 'wut').text).to eq('ok')
     end
   end
 
   describe '.delete' do
-    async 'fetches a path' do
+    it 'fetches a path' do
       Browser::HTTP.delete(path).then {|res|
-        run_async {
-          res.text.should == 'lol'
-        }
+        expect(res.text).to eq('lol')
       }.rescue {
-        run_async {
-          fail
-        }
+        fail
       }
     end
   end
 
   describe '.delete!' do
     it 'fetches a path' do
-      Browser::HTTP.delete!(path).text.should == 'lol'
+      expect(Browser::HTTP.delete!(path).text).to eq('lol')
     end
   end
-end
+end if Browser::HTTP.supported?

data/spec/immediate_spec.rb

@@ -1,12 +1,15 @@
 require 'spec_helper'
 require 'browser/immediate'
 
-describe Browser::Immediate do
-  async 'defers a proc' do
-    proc {|a|
-      run_async {
-        a.should == 42
-      }
-    }.defer(42)
+describe Proc do
+  describe '#defer' do
+    it 'defers the parameters' do
+      promise = Browser::Promise.new
+      proc {|a|
+        expect(a).to eq(42)
+        promise.resolve
+      }.defer(42)
+      promise.for_rspec
+    end
   end
 end

data/spec/interval_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'browser/interval'
+
+describe Browser::Window do
+  describe '#every' do
+    it 'calls the block multiple times' do
+      x = 0
+
+      promise = Browser::Promise.new
+      $window.every 0.3 do
+        x += 1
+
+        if x == 3
+          expect(true).to be_truthy
+          promise.resolve
+        end
+      end
+      promise.for_rspec
+    end
+  end
+end
+
+describe Kernel do
+  describe '#every' do
+    it 'calls the block multiple times' do
+      x = 0
+
+      promise = Browser::Promise.new
+      every 0.3 do
+        x += 1
+
+        if x == 3
+          expect(true).to be_truthy
+          promise.resolve
+        end
+      end
+      promise.for_rspec
+    end
+  end
+end
+
+describe Proc do
+  describe '#every' do
+    it 'calls the block multiple times' do
+      x = 0
+
+      promise = Browser::Promise.new
+      -> {
+        x += 1
+
+        if x == 3
+          expect(true).to be_truthy
+          promise.resolve
+        end
+      }.every 0.3
+      promise.for_rspec
+    end
+  end
+end

data/spec/native_cached_wrapper_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Browser::NativeCachedWrapper do
+  it 'deduplicates DOM objects' do
+    expect($document.at_css("body").hash).to eq($document.body.hash)
+    expect($document.body.hash).not_to eq($document.body.dup.hash) # Should dup/clone have different semantics?
+    expect($document.body.hash).not_to eq($document.head.hash)
+  end
+
+  it 'accurately intercepts the last new call' do
+    class Demo
+      include Browser::NativeCachedWrapper
+
+      def self.new(arg1, arg2)
+        super(`{arg1: #{arg1}, arg2: #{arg2}}`)
+      end
+
+      def data
+        [:data, `#@native.arg1`, `#@native.arg2`]
+      end
+    end
+
+    class SuperDemo < Demo
+      def self.new(arg1, arg2, arg3)
+        super("superdemo", "#{arg1} - #{arg2} - #{arg3}")
+      end
+    end
+
+    expect(Demo.new("a", "b").data).to eq([:data, "a", "b"])
+    expect(SuperDemo.new("1", "2", "3").data).to eq([:data, "superdemo", "1 - 2 - 3"])
+  end
+
+  html <<-HTML
+    <iframe id='ifr' src='about:blank' sandbox=''></iframe>
+  HTML
+
+  it 'supports restricted objects' do
+    # Window won't be restricted
+    expect($window.restricted?).to eq(false)
+    # Iframe itself won't be restricted
+    expect($document['ifr'].restricted?).to eq(false)
+    # But its content_window will be (due to CORS)
+    expect($document['ifr'].content_window.restricted?).to eq(true)
+  end
+end
+

data/spec/runner.rb

@@ -0,0 +1,107 @@
+#! /usr/bin/env ruby
+require 'webdrivers'
+require 'selenium/webdriver'
+require 'rest_client'
+require 'json'
+
+print 'Loading...'
+
+browser, options = case ENV['BROWSER']
+when "chrome"
+  opts = Selenium::WebDriver::Chrome::Options.new(args: ['--headless', '--no-sandbox'])
+  [:chrome, opts]
+when "gecko"
+  opts = Selenium::WebDriver::Firefox::Options.new(args: ['--headless'])
+  [:firefox, opts]
+when "safari"
+  opts = Selenium::WebDriver::Safari::Options.new()
+  [:safari, opts]
+when "edge"
+  opts = Selenium::WebDriver::Edge::Options.new(args: ['--headless'])
+  [:edge, opts]
+else
+  raise "Wrong web browser provided in BROWSER. Acceptable values: chrome, gecko, safari, edge"
+end
+
+browser = Selenium::WebDriver.for(browser, capabilities: options)
+browser.navigate.to('http://localhost:9292')
+
+# if we don't quit the browser it will stall
+at_exit {
+  browser.quit
+}
+
+puts "Browser: " + browser.execute_script("return window.navigator.userAgent")
+
+# the title is a good way to know if anything went wrong while fetching the
+# page
+Selenium::WebDriver::Wait.new(timeout: 30, interval: 5).until {
+  not browser.title.strip.empty?
+}
+
+unless browser.title =~ /Opal Browser|RSpec results/
+  puts "\rThe page failed loading."
+  exit 1
+end
+
+# wait until the specs are running or there has been an error in the loading of
+# the specs
+begin
+  Selenium::WebDriver::Wait.new(timeout: 30, interval: 5).until {
+    (browser['rspec-error'] rescue false) ||
+    (browser[class: 'rspec-report'] rescue false)
+  }
+
+  if element = browser['rspec-error'] rescue nil
+    puts "\r#{element.text}"
+    exit 1
+  end
+rescue Selenium::WebDriver::Error::TimeoutError; end
+
+print "\rRunning specs..."
+
+begin
+  # wait until the specs have finished, thus changing the content of #totals
+  Selenium::WebDriver::Wait.new(timeout: 3000, interval: 30).until {
+    print '.'
+
+    not browser['totals'].text.strip.empty?
+  }
+
+  totals   = browser['totals'].text
+  duration = browser[css: '#duration strong'].text
+
+  print "\r#{totals} in #{duration}"
+
+  # no failures, happy times
+  if totals =~ / 0 failures/
+    exit 0
+  end
+rescue Selenium::WebDriver::Error::TimeoutError
+  if element = browser['rspec-error'] rescue nil
+    print "\r#{element.text}"
+  else
+    print "\rThe specs have timed out."
+  end
+ensure
+  # take a screenshot and upload it to imgur
+  begin
+    upload = lambda do |filepath|
+      response = RestClient.post('https://api.imgur.com/3/upload',
+        { image: File.open(filepath) },
+        { 'Authorization' => 'Client-ID 1979876fe2a097e' })
+
+      JSON.parse(response.to_str)['data']['link']
+    end
+
+    w, h = browser.execute_script("return [document.body.clientWidth, document.body.clientHeight];")
+    browser.manage.window.resize_to(w, h)
+    browser.save_screenshot('screenshot.png')
+    screenshot_url = upload.('screenshot.png')
+    puts " (#{screenshot_url})"
+  rescue Exception
+    puts
+  end
+end
+
+exit 1

data/spec/socket_spec.rb

@@ -1,43 +1,47 @@
 require 'spec_helper'
+require 'browser/location'
 require 'browser/socket'
 
 describe Browser::Socket do
   # FIXME: find out why it doesn't work inline
   ws = "ws://#{$window.location.host}/socket"
 
-  async 'creates a socket' do
+  it 'creates a socket' do
+    promise = Browser::Promise.new
     Browser::Socket.new ws do |s|
       s.on :open do |e|
-        run_async {
-          e.target.should be_kind_of Browser::Socket
-        }
+        expect(e.target).to be_a(Browser::Socket)
+        promise.resolve
       end
     end
+    promise.for_rspec
   end
 
-  async 'receives messages' do
+  it 'receives messages' do
+    promise = Browser::Promise.new
     Browser::Socket.new ws do |s|
       s.on :message do |e|
-        run_async {
-          e.data.should == 'lol'
-        }
+        expect(e.data).to eq('lol')
+        promise.resolve
       end
     end
+    promise.for_rspec
   end
 
-  async 'sends messages' do
+  it 'sends messages' do
+    promise = Browser::Promise.new
     Browser::Socket.new ws do |s|
       s.on :message do |e|
+        e.off
+
         s.print 'omg'
 
         s.on :message do |e|
-          run_async {
-            e.data.should == 'omg'
-          }
+          expect(e.data).to eq('omg')
+          promise.resolve
         end
-
-        e.off
       end
     end
+    promise.for_rspec
   end
 end if Browser::Socket.supported?

data/spec/spec_helper.rb

@@ -1,8 +1,6 @@
-require 'json2'
-require 'sizzle'
-
+require 'spec_helper_promise'
 require 'browser'
-require 'browser/console'
+require 'console'
 
 module HtmlHelper
   # Add some html code to the body tag ready for testing. This will

data/spec/spec_helper_promise.rb.erb

@@ -0,0 +1,25 @@
+<% if ENV['OPAL_BROWSER_PROMISE'] == 'v2' %>
+  require 'promise'
+  require 'promise/v2'
+<% else %>
+  require 'promise'
+
+  # Polyfill #to_v1, which isn't present before Opal v1.3.0
+  class Promise
+    unless Promise.method_defined? :to_v1
+      alias to_v1 itself
+    end
+  end
+<% end %>
+
+require 'browser/utils'
+
+module Browser
+  class Promise
+    # Return a correct promise for opal-rspec, which for now is
+    # PromiseV1 until opal-rspec is ported.
+    def for_rspec
+      to_v1
+    end
+  end
+end