undead 0.1.1 → 0.2.0

data/lib/undead/command.rb

@@ -0,0 +1,20 @@
+require "json"
+require "securerandom"
+
+module Undead
+  class Command
+    attr_reader :id
+    attr_reader :name
+    attr_accessor :args
+
+    def initialize(name, *args)
+      @id = SecureRandom.uuid
+      @name = name
+      @args = args
+    end
+
+    def message
+      JSON.dump({ 'id' => @id, 'name' => @name, 'args' => @args })
+    end
+  end
+end

data/lib/undead/driver.rb

@@ -0,0 +1,73 @@
+require "undead/browser"
+require "undead/client"
+require "undead/server"
+
+module Undead
+  class Driver
+    DEFAULT_TIMEOUT = 30
+
+    attr_accessor :options
+
+    def initialize(options = {})
+      @options = options
+      headers = options.fetch(:headers, {})
+    end
+
+    def browser
+      @browser ||= begin
+        browser = Undead::Browser.new(server, client, logger)
+        browser.js_errors  = options[:js_errors] if options.key?(:js_errors)
+        browser.debug      = true if options[:debug]
+        browser
+      end
+    end
+
+    def server
+      @server ||= Undead::Server.new(options[:port], options.fetch(:timeout) { DEFAULT_TIMEOUT })
+    end
+
+    def client
+      @client ||= Undead::Client.start(server,
+        :path              => options[:phantomjs],
+        :window_size       => options[:window_size],
+        :phantomjs_options => phantomjs_options,
+        :phantomjs_logger  => phantomjs_logger
+      )
+    end
+
+    def phantomjs_options
+      list = options[:phantomjs_options] || []
+
+      # PhantomJS defaults to only using SSLv3, which since POODLE (Oct 2014)
+      # many sites have dropped from their supported protocols (eg PayPal,
+      # Braintree).
+      list += ["--ignore-ssl-errors=yes"] unless list.grep(/ignore-ssl-errors/).any?
+      list += ["--ssl-protocol=TLSv1"] unless list.grep(/ssl-protocol/).any?
+      list
+    end
+
+    def logger
+      options[:logger] || (options[:debug] && STDERR)
+    end
+
+    def phantomjs_logger
+      options.fetch(:phantomjs_logger, nil)
+    end
+
+    def headers
+      browser.get_headers
+    end
+
+    def headers=(headers)
+      browser.set_headers(headers)
+    end
+
+    def visit(url)
+      browser.visit(url)
+    end
+
+    def html
+      browser.body
+    end
+  end
+end

data/lib/undead/errors.rb

@@ -0,0 +1,187 @@
+module Undead
+  class Error < StandardError; end
+  class NoSuchWindowError < Error; end
+
+  class ClientError < Error
+    attr_reader :response
+
+    def initialize(response)
+      @response = response
+    end
+  end
+
+  class JSErrorItem
+    attr_reader :message, :stack
+
+    def initialize(message, stack)
+      @message = message
+      @stack   = stack
+    end
+
+    def to_s
+      [message, stack].join("\n")
+    end
+  end
+
+  class BrowserError < ClientError
+    def name
+      response['name']
+    end
+
+    def error_parameters
+      response['args'].join("\n")
+    end
+
+    def message
+      "There was an error inside the PhantomJS portion of Poltergeist. " \
+        "If this is the error returned, and not the cause of a more detailed error response, " \
+        "this is probably a bug, so please report it. " \
+        "\n\n#{name}: #{error_parameters}"
+    end
+  end
+
+  class JavascriptError < ClientError
+    def javascript_errors
+      response['args'].first.map { |data| JSErrorItem.new(data['message'], data['stack']) }
+    end
+
+    def message
+      "One or more errors were raised in the Javascript code on the page. " \
+        "If you don't care about these errors, you can ignore them by " \
+        "setting js_errors: false in your Poltergeist configuration (see " \
+        "documentation for details)." \
+        "\n\n#{javascript_errors.map(&:to_s).join("\n")}"
+    end
+  end
+
+  class StatusFailError < ClientError
+    def url
+      response['args'].first
+    end
+
+    def details
+      response['args'][1]
+    end
+
+    def message
+      msg = "Request to '#{url}' failed to reach server, check DNS and/or server status"
+      msg += " - #{details}" if details
+      msg
+    end
+  end
+
+  class FrameNotFound < ClientError
+    def name
+      response['args'].first
+    end
+
+    def message
+      "The frame '#{name}' was not found."
+    end
+  end
+
+  class InvalidSelector < ClientError
+    def method
+      response['args'][0]
+    end
+
+    def selector
+      response['args'][1]
+    end
+
+    def message
+      "The browser raised a syntax error while trying to evaluate " \
+        "#{method} selector #{selector.inspect}"
+    end
+  end
+
+  class NodeError < ClientError
+    attr_reader :node
+
+    def initialize(node, response)
+      @node = node
+      super(response)
+    end
+  end
+
+  class ObsoleteNode < NodeError
+    def message
+      "The element you are trying to interact with is either not part of the DOM, or is " \
+        "not currently visible on the page (perhaps display: none is set). " \
+        "It's possible the element has been replaced by another element and you meant to interact with " \
+        "the new element. If so you need to do a new 'find' in order to get a reference to the " \
+        "new element."
+    end
+  end
+
+  class MouseEventFailed < NodeError
+    def name
+      response['args'][0]
+    end
+
+    def selector
+      response['args'][1]
+    end
+
+    def position
+      [response['args'][2]['x'], response['args'][2]['y']]
+    end
+
+    def message
+      "Firing a #{name} at co-ordinates [#{position.join(', ')}] failed. Poltergeist detected " \
+        "another element with CSS selector '#{selector}' at this position. " \
+        "It may be overlapping the element you are trying to interact with. " \
+        "If you don't care about overlapping elements, try using node.trigger('#{name}')."
+    end
+  end
+
+  class TimeoutError < Error
+    def initialize(message)
+      @message = message
+    end
+
+    def message
+      "Timed out waiting for response to #{@message}. It's possible that this happened " \
+        "because something took a very long time (for example a page load was slow). " \
+        "If so, setting the Poltergeist :timeout option to a higher value will help " \
+        "(see the docs for details). If increasing the timeout does not help, this is " \
+        "probably a bug in Poltergeist - please report it to the issue tracker."
+    end
+  end
+
+  class DeadClient < Error
+    def initialize(message)
+      @message = message
+    end
+
+    def message
+      "PhantomJS client died while processing #{@message}"
+    end
+  end
+
+  class PhantomJSTooOld < Error
+    def self.===(other)
+      if Cliver::Dependency::VersionMismatch === other
+        warn "#{name} exception has been deprecated in favor of using the " +
+             "cliver gem for command-line dependency detection. Please " +
+             "handle Cliver::Dependency::VersionMismatch instead."
+        true
+      else
+        super
+      end
+    end
+  end
+
+  class PhantomJSFailed < Error
+    def self.===(other)
+      if Cliver::Dependency::NotMet === other
+        warn "#{name} exception has been deprecated in favor of using the " +
+             "cliver gem for command-line dependency detection. Please " +
+             "handle Cliver::Dependency::NotMet instead."
+        true
+      else
+        super
+      end
+    end
+  end
+end

data/lib/undead/server.rb

@@ -0,0 +1,44 @@
+require "undead/errors"
+require "undead/web_socket_server"
+
+module Undead
+  class Server
+    attr_reader :socket, :fixed_port, :timeout
+
+    def initialize(fixed_port = nil, timeout = nil)
+      @fixed_port = fixed_port
+      @timeout    = timeout
+      start
+    end
+
+    def port
+      @socket.port
+    end
+
+    def timeout=(sec)
+      @timeout = @socket.timeout = sec
+    end
+
+    def start
+      @socket = Undead::WebSocketServer.new(fixed_port, timeout)
+    end
+
+    def stop
+      @socket.close
+    end
+
+    def restart
+      stop
+      start
+    end
+
+    def send(command)
+      receive_timeout = nil # default
+      if command.name == 'visit'
+        command.args.push(timeout) # set the client set visit timeout parameter
+        receive_timeout = timeout + 5 # Add a couple of seconds to let the client timeout first
+      end
+      @socket.send(command.id, command.message, receive_timeout) or raise Undead::DeadClient.new(command.message)
+    end
+  end
+end

data/lib/undead/utility.rb

@@ -0,0 +1,7 @@
+module Undead
+  class << self
+    def windows?
+      RbConfig::CONFIG["host_os"] =~ /mingw|mswin|cygwin/
+    end
+  end
+end

data/lib/undead/version.rb

@@ -1,3 +1,3 @@
 module Undead
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/undead/web_socket_server.rb

@@ -0,0 +1,109 @@
+require "json"
+require "socket"
+require "websocket/driver"
+
+module Undead
+  # This is a 'custom' Web Socket server that is designed to be synchronous. What
+  # this means is that it sends a message, and then waits for a response. It does
+  # not expect to receive a message at any other time than right after it has sent
+  # a message. So it is basically operating a request/response cycle (which is not
+  # how Web Sockets are usually used, but it's what we want here, as we want to
+  # send a message to PhantomJS and then wait for it to respond).
+  class WebSocketServer
+    # How much to try to read from the socket at once (it's kinda arbitrary because we
+    # just keep reading until we've received a full frame)
+    RECV_SIZE = 1024
+
+    # How many seconds to try to bind to the port for before failing
+    BIND_TIMEOUT = 5
+
+    HOST = '127.0.0.1'
+
+    attr_reader :port, :driver, :socket, :server
+    attr_accessor :timeout
+
+    def initialize(port = nil, timeout = nil)
+      @timeout = timeout
+      @server  = start_server(port)
+      @receive_mutex = Mutex.new
+    end
+
+    def start_server(port)
+      time = Time.now
+
+      begin
+        TCPServer.open(HOST, port || 0).tap do |server|
+          @port = server.addr[1]
+        end
+      rescue Errno::EADDRINUSE
+        if (Time.now - time) < BIND_TIMEOUT
+          sleep(0.01)
+          retry
+        else
+          raise
+        end
+      end
+    end
+
+    def connected?
+      !socket.nil?
+    end
+
+    # Accept a client on the TCP server socket, then receive its initial HTTP request
+    # and use that to initialize a Web Socket.
+    def accept
+      @socket   = server.accept
+      @messages = {}
+
+      @driver = ::WebSocket::Driver.server(self)
+      @driver.on(:connect) { |event| @driver.start }
+      @driver.on(:message) do |event|
+        command_id = JSON.load(event.data)['command_id']
+        @messages[command_id] = event.data
+      end
+    end
+
+    def write(data)
+      @socket.write(data)
+    end
+
+    # Block until the next message is available from the Web Socket.
+    # Raises Errno::EWOULDBLOCK if timeout is reached.
+    def receive(cmd_id, receive_timeout=nil)
+      receive_timeout ||= timeout
+      start = Time.now
+
+      until @messages.has_key?(cmd_id)
+        raise Errno::EWOULDBLOCK if (Time.now - start) >= receive_timeout
+        if @receive_mutex.try_lock
+          begin
+            IO.select([socket], [], [], receive_timeout) or raise Errno::EWOULDBLOCK
+            data = socket.recv(RECV_SIZE)
+            break if data.empty?
+            driver.parse(data)
+          ensure
+            @receive_mutex.unlock
+          end
+        else
+          sleep(0.05)
+        end
+      end
+      @messages.delete(cmd_id)
+    end
+
+    # Send a message and block until there is a response
+    def send(cmd_id, message, accept_timeout=nil)
+      accept unless connected?
+      driver.text(message)
+      receive(cmd_id, accept_timeout)
+    rescue Errno::EWOULDBLOCK
+      raise TimeoutError.new(message)
+    end
+
+    # Closing sockets separately as `close_read`, `close_write`
+    # causes IO mistakes on JRuby, using just `close` fixes that.
+    def close
+      [server, socket].compact.each(&:close)
+    end
+  end
+end