opal-browser 0.2.0.beta1 → 0.3.2

data/spec/history_spec.rb

@@ -19,39 +19,43 @@ describe Browser::History do
   end
 
   describe '#back' do
-    async 'should go back once' do
+    it 'should go back once' do
       expect($window.history.current).to eq('/')
       $window.history.push('/wut')
       expect($window.history.current).to eq('/wut')
 
-      $window.on 'pop:state' do |e|
-        e.off
+      promise = Browser::Promise.new
 
-        async {
-          expect($window.history.current).to eq('/')
-        }
+      $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
-    async 'gets the right state' do
-      $window.history.push('/wut', 42)
-      $window.history.state.should eq(42)
-      $window.history.push('/omg', 23)
-      $window.history.state.should eq(23)
-
-      $window.on 'pop:state' do |e|
-        e.off
-
-        async {
+    it 'gets the right state' do
+      # 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)
-        }
-      end
+          promise.resolve
+        end
 
-      $window.history.back(2)
+        $window.history.back(2)
+      end
+      promise.for_rspec
     end
   end if Browser.supports? 'History.state'
 end if Browser::History.supported?

data/spec/http_spec.rb

@@ -2,20 +2,15 @@ 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|
-        async {
-          expect(res.text).to eq('lol')
-        }
+        expect(res.text).to eq('lol')
       }.rescue {
-        async {
-          fail
-        }
+        fail
       }
     end
   end
@@ -27,15 +22,11 @@ describe Browser::HTTP do
   end
 
   describe '.post' do
-    async 'sends parameters properly' do
+    it 'sends parameters properly' do
       Browser::HTTP.post(path, lol: 'wut').then {|res|
-        async {
-          expect(res.text).to eq('ok')
-        }
+        expect(res.text).to eq('ok')
       }.rescue {
-        async {
-          fail
-        }
+        fail
       }
     end
   end
@@ -44,18 +35,19 @@ describe Browser::HTTP do
     it 'sends parameters properly' do
       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|
-        async {
-          expect(res.text).to eq('ok')
-        }
+        expect(res.text).to eq('ok')
       }.rescue {
-        async {
-          fail
-        }
+        fail
       }
     end
   end
@@ -67,15 +59,11 @@ describe Browser::HTTP do
   end
 
   describe '.delete' do
-    async 'fetches a path' do
+    it 'fetches a path' do
       Browser::HTTP.delete(path).then {|res|
-        async {
-          expect(res.text).to eq('lol')
-        }
+        expect(res.text).to eq('lol')
       }.rescue {
-        async {
-          fail
-        }
+        fail
       }
     end
   end

data/spec/immediate_spec.rb

@@ -3,12 +3,13 @@ require 'browser/immediate'
 
 describe Proc do
   describe '#defer' do
-    async 'defers the parameters' do
+    it 'defers the parameters' do
+      promise = Browser::Promise.new
       proc {|a|
-        async {
-          expect(a).to eq(42)
-        }
+        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

@@ -1,67 +1,45 @@
 #! /usr/bin/env ruby
+require 'webdrivers'
 require 'selenium/webdriver'
 require 'rest_client'
 require 'json'
 
-# setup tunnel
-begin
-  File.open('tunnel.jar', 'w') {|f|
-    f.write RestClient.get('http://www.browserstack.com/BrowserStackTunnel.jar').to_str
-  }
-
-  tunnel = IO.popen 'java -jar tunnel.jar $BS_AUTHKEY localhost,9292,0 -tunnelIdentifier $TRAVIS_JOB_ID'
-
-  loop do
-    break if tunnel.gets.start_with? 'You can now access'
-  end
-end
-
-# configure based on environment variables
-hub  = "http://#{ENV['BS_USERNAME']}:#{ENV['BS_AUTHKEY']}@hub.browserstack.com/wd/hub"
-plan = "https://#{ENV['BS_USERNAME']}:#{ENV['BS_AUTHKEY']}@www.browserstack.com/automate/plan.json"
-cap  = Selenium::WebDriver::Remote::Capabilities.new
-
-cap['platform']        = ENV['SELENIUM_PLATFORM'] || 'ANY'
-cap['browser']         = ENV['SELENIUM_BROWSER'] || 'chrome'
-cap['browser_version'] = ENV['SELENIUM_VERSION'] if ENV['SELENIUM_VERSION']
-
-cap['browserstack.tunnelIdentifier'] = ENV['TRAVIS_JOB_ID']
-cap['browserstack.tunnel']           = 'true'
-cap['browserstack.debug']            = 'false'
-
 print 'Loading...'
 
-# wait until there's a spot in the parallel jobs
-begin
-  loop do
-    state = JSON.parse(RestClient.get(plan).to_str)
-
-    if state["parallel_sessions_running"] < state["parallel_sessions_max_allowed"]
-      break
-    end
-
-    print '.'
-    sleep 30
-  end
-
-  browser = Selenium::WebDriver.for(:remote, url: hub, desired_capabilities: cap)
-  browser.navigate.to('http://localhost:9292')
-rescue Selenium::WebDriver::Error::UnknownError
-  retry
+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/
+unless browser.title =~ /Opal Browser|RSpec results/
   puts "\rThe page failed loading."
   exit 1
 end
@@ -78,37 +56,52 @@ begin
     puts "\r#{element.text}"
     exit 1
   end
-rescue Selenium::WebDriver::Error::TimeOutError; end
+rescue Selenium::WebDriver::Error::TimeoutError; end
 
 print "\rRunning specs..."
 
-# wait until the specs have finished, thus changing the content of #totals
-Selenium::WebDriver::Wait.new(timeout: 1200, interval: 30).until {
-  print '.'
+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?
-}
+    not browser['totals'].text.strip.empty?
+  }
 
-totals   = browser['totals'].text
-duration = browser[css: '#duration strong'].text
+  totals   = browser['totals'].text
+  duration = browser[css: '#duration strong'].text
 
-print "\r#{totals} in #{duration}"
+  print "\r#{totals} in #{duration}"
 
-# take a screenshot and upload it to imgur
-begin
-  browser.save_screenshot('screenshot.png')
-  response = RestClient.post('https://api.imgur.com/3/upload',
-    { image: File.open('screenshot.png') },
-    { 'Authorization' => 'Client-ID 1979876fe2a097e' })
-
-  print " ("
-  print JSON.parse(response.to_str)['data']['link']
-  puts  ")"
-rescue Exception
-  puts
-end
+  # 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
 
-# no failures, happy times
-unless totals =~ / 0 failures/
-  exit 1
+    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,31 +1,35 @@
 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|
-        async {
-          expect(e.target).to be_a(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|
-        async {
-          expect(e.data).to eq('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
@@ -33,11 +37,11 @@ describe Browser::Socket do
         s.print 'omg'
 
         s.on :message do |e|
-          async {
-            expect(e.data).to eq('omg')
-          }
+          expect(e.data).to eq('omg')
+          promise.resolve
         end
       end
     end
+    promise.for_rspec
   end
 end if Browser::Socket.supported?

data/spec/spec_helper.rb

@@ -1,9 +1,6 @@
-require 'json2'
-require 'sizzle'
-require 'wgxpath.install'
-
+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

data/spec/storage_spec.rb

@@ -22,5 +22,5 @@ describe Browser::Window do
       expect($window.session_storage.name).to eq(:default)
       expect($window.session_storage(:spec).name).to eq(:spec)
     end
-  end
+  end if Browser::SessionStorage.supported?
 end