eyes_core 4.0.5.4 → 4.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec9862ed447e764b35cfaddd3c5fa05911ab90a532669abc2c11f5bec85f1bc3
-  data.tar.gz: 4af83732ec7f6f5ebb7e5f8cff6353cd1c498550869164a93e84099acaff32ca
+  metadata.gz: c116a6e522739b1716552ad9e5c33e64b19c9a3f5bf4f0adef899d5384813647
+  data.tar.gz: b2fcacf6df345e0b2c74f428c64883cca0e5f38468f330ff0ea26c29793f4e7a
 SHA512:
-  metadata.gz: 694dfd9c89cfc9301eca0858782c376bfc73900ff6b2b8ef884fed0ffde1a9db9fd44c95d9731eb50206ded31410121e6b6bcac5c8771867d75386fc44b06309
-  data.tar.gz: eac81e62050881ca7a473d437dbf078ee3f72999777bfab1edcd762b8a163b18558a56db71b3294a0255fd05b801ecfc143c9bd11f5dd42b6794ac3b3f48efb6
+  metadata.gz: 677efbddf2a5eab5e782e08a8eeb6f9107aa7bd40ecf96509688cd67205d767093fa48da27a21ec24a6fe0fef0f223d22150773fee985fb2699abf74b3238780
+  data.tar.gz: 3dc4ebbf3e97e32c1d15b809ed78f48011de9b7e2cfe49114a683d73ce0cd3b26167101c8e419d8253c0f71278d34e43a014db256605d9cf622747a5cc885967

data/lib/applitools/universal_sdk/universal_check_settings.rb

@@ -15,7 +15,8 @@ module Applitools
     #     renderId?: string
     #     variationGroupId?: string
     #     timeout?: number
-    #     waitBeforeCapture?: number
+    #     waitBeforeCapture?: number,
+    #     lazyLoad?: boolean | LazyLoadOptions
     #   }
     json_fields :name,
       :disableBrowserFetching,
@@ -26,7 +27,8 @@ module Applitools
       :renderId,
       :variationGroupId,
       :timeout,
-      :waitBeforeCapture
+      :waitBeforeCapture,
+      :lazyLoad
 
     # export type MatchSettings<TRegion> = {
     #   exact?: {
@@ -144,6 +146,7 @@ module Applitools
       self.timeout = target.options[:timeout]
       self.variation_group_id = target.options[:variation_group_id]
       self.wait_before_capture = target.options[:wait_before_capture]
+      self.lazy_load = target.options[:lazy_load]
       self.page_id = target.options[:page_id]
 
       self.scroll_root_element = target.options[:scroll_root_element] || eyes.scroll_root_element

data/lib/applitools/universal_sdk/universal_client.rb

@@ -1,10 +1,15 @@
 # frozen_string_literal: true
 
-require 'eventmachine'
-
 # require_relative 'universal_client_socket'
 # require_relative 'universal_eyes_manager'
 
+require 'json'
+require 'securerandom'
+require 'colorize'
+require 'websocket'
+require 'uri'
+
+
 module Applitools::Connectivity
   class UniversalClient
 
@@ -29,9 +34,8 @@ module Applitools::Connectivity
     EYES_ABORT = 'Eyes.abort'
 
 
-    def initialize(queue = EM::Queue.new)
-      @socket = Applitools::Connectivity::UniversalClientSocket.new
-      @queue = queue
+    def initialize
+      # @socket = Applitools::Connectivity::UniversalClientSocket.new
       prepare_socket
       # store on open for next check calls
       @open_config = nil
@@ -46,51 +50,62 @@ module Applitools::Connectivity
 
 
     def core_make_manager(eyes_manager_config)
-      await(->(cb) { @socket.request(CORE_MAKE_MANAGER, eyes_manager_config, cb) })
+      # await(->(cb) { @socket.request(CORE_MAKE_MANAGER, eyes_manager_config, cb) })
+      command_with_result(CORE_MAKE_MANAGER, eyes_manager_config)
     end
 
     def eyes_manager_make_eyes(manager, driver_config, config)
       @open_config = config
 
-      await(->(cb) {
-        @socket.request(EYES_MANAGER_MAKE_EYES, {manager: manager, driver: driver_config, config: config}, cb)
-      })
+      # await(->(cb) {
+      #   @socket.request(EYES_MANAGER_MAKE_EYES, {manager: manager, driver: driver_config, config: config}, cb)
+      # })
+      command_with_result(EYES_MANAGER_MAKE_EYES, {manager: manager, driver: driver_config, config: config})
     end
 
     def eyes_manager_close_all_eyes(manager)
-      await(->(cb) { @socket.request(EYES_MANAGER_CLOSE_ALL_EYES, {manager: manager}, cb) })
+      # await(->(cb) { @socket.request(EYES_MANAGER_CLOSE_ALL_EYES, {manager: manager}, cb) })
+      command_with_result(EYES_MANAGER_CLOSE_ALL_EYES, {manager: manager})
     end
 
     def eyes_check(eyes, settings)
-      await(->(cb) { @socket.request(EYES_CHECK, {eyes: eyes, settings: settings, config: @open_config}, cb) })
+      # await(->(cb) { @socket.request(EYES_CHECK, {eyes: eyes, settings: settings, config: @open_config}, cb) })
+      command_with_result(EYES_CHECK, {eyes: eyes, settings: settings, config: @open_config})
     end
 
     def eyes_locate(eyes, settings)
-      await(->(cb) { @socket.request(EYES_LOCATE, {eyes: eyes, settings: settings, config: @open_config}, cb) })
+      # await(->(cb) { @socket.request(EYES_LOCATE, {eyes: eyes, settings: settings, config: @open_config}, cb) })
+      command_with_result(EYES_LOCATE, {eyes: eyes, settings: settings, config: @open_config})
     end
 
     def eyes_extract_text_regions(eyes, settings)
-      await(->(cb) { @socket.request(EYES_EXTRACT_TEXT_REGIONS, {eyes: eyes, settings: settings, config: @open_config}, cb) })
+      # await(->(cb) { @socket.request(EYES_EXTRACT_TEXT_REGIONS, {eyes: eyes, settings: settings, config: @open_config}, cb) })
+      command_with_result(EYES_EXTRACT_TEXT_REGIONS, {eyes: eyes, settings: settings, config: @open_config})
     end
 
     def eyes_extract_text(eyes, regions)
-      await(->(cb) { @socket.request(EYES_EXTRACT_TEXT, {eyes: eyes, regions: regions, config: @open_config}, cb) })
+      # await(->(cb) { @socket.request(EYES_EXTRACT_TEXT, {eyes: eyes, regions: regions, config: @open_config}, cb) })
+      command_with_result(EYES_EXTRACT_TEXT, {eyes: eyes, regions: regions, config: @open_config})
     end
 
     def eyes_close(eyes)
-      await(->(cb) { @socket.request(EYES_CLOSE, {eyes: eyes}, cb) })
+      # await(->(cb) { @socket.request(EYES_CLOSE, {eyes: eyes}, cb) })
+      command_with_result(EYES_CLOSE, {eyes: eyes})
     end
 
     def eyes_abort(eyes)
-      await(->(cb) { @socket.request(EYES_ABORT, {eyes: eyes}, cb) })
+      # await(->(cb) { @socket.request(EYES_ABORT, {eyes: eyes}, cb) })
+      command_with_result(EYES_ABORT, {eyes: eyes})
     end
 
     def core_get_viewport_size(driver)
-      await(->(cb) { @socket.request(CORE_GET_VIEWPORT_SIZE, {driver: driver}, cb) })
+      # await(->(cb) { @socket.request(CORE_GET_VIEWPORT_SIZE, {driver: driver}, cb) })
+      command_with_result(CORE_GET_VIEWPORT_SIZE, {driver: driver})
     end
 
     def core_set_viewport_size(driver, size)
-      await(->(cb) { @socket.request(CORE_SET_VIEWPORT_SIZE, {driver: driver, size: size}, cb) })
+      # await(->(cb) { @socket.request(CORE_SET_VIEWPORT_SIZE, {driver: driver, size: size}, cb) })
+      command_with_result(CORE_SET_VIEWPORT_SIZE, {driver: driver, size: size})
     end
 
     def core_close_batches(close_batch_settings=nil)
@@ -102,12 +117,14 @@ module Applitools::Connectivity
         optional = [:serverUrl, :apiKey, :proxy].map {|k| [k, @open_config[k]] }.to_h
         close_batch_settings = { settings: ({ batchIds: batch_ids }.merge(optional).compact) }
       end
-      await(->(cb) { @socket.request(CORE_CLOSE_BATCHES, close_batch_settings, cb) })
+      # await(->(cb) { @socket.request(CORE_CLOSE_BATCHES, close_batch_settings, cb) })
+      command_with_result(CORE_CLOSE_BATCHES, close_batch_settings)
     end
 
     def core_delete_test(delete_test_settings)
       # testId, batchId, secretToken, serverUrl, apiKey?, proxy?
-      await(->(cb) { @socket.request(CORE_DELETE_TEST, delete_test_settings, cb) })
+      # await(->(cb) { @socket.request(CORE_DELETE_TEST, delete_test_settings, cb) })
+      command_with_result(CORE_DELETE_TEST, delete_test_settings)
     end
 
 
@@ -115,33 +132,112 @@ module Applitools::Connectivity
 
 
     def prepare_socket
-      socket_uri = ::Applitools::Connectivity::UniversalServer.check_or_run
-      connect_and_configure_socket(socket_uri)
-    end
-
-    def connect_and_configure_socket(uri)
-      Thread.new do
-        EM.run do
-          @socket.connect(uri)
-          @socket.emit(SESSION_INIT, {
-            name: :rb,
-            version: ::Applitools::VERSION,
-            protocol: :webdriver,
-            cwd: Dir.pwd
-          })
+      @web_socket = ::Applitools::Connectivity::UniversalServer.check_or_run
+      socket_handshake
+      session_init
+      # connect_and_configure_socket(socket_uri)
+    end
+
+    # def prepare_socket
+    #   socket_uri = ::Applitools::Connectivity::UniversalServer.check_or_run
+    #   connect_and_configure_socket(socket_uri)
+    # end
+    #
+    # def connect_and_configure_socket(uri)
+    #   @socket.connect(uri)
+    #   @socket.emit(SESSION_INIT, {
+    #     name: :rb,
+    #     version: ::Applitools::VERSION,
+    #     protocol: :webdriver,
+    #     cwd: Dir.pwd
+    #   })
+    # end
+    #
+    # def await(function)
+    #   resolved = false
+    #   cb = ->(result) {
+    #     resolved = result
+    #   }
+    #   function.call(cb)
+    #   sleep 1 until !!resolved
+    #   resolved
+    # end
+
+
+    def socket_handshake
+      ip = @web_socket.remote_address.ip_address
+      port = @web_socket.remote_address.ip_port
+      socket_uri = "ws://#{ip}:#{port}/eyes"
+      handshake = WebSocket::Handshake::Client.new(url: socket_uri)
+      @web_socket.write(handshake)
+      web_socket_result = receive_result('handshake')
+      handshake << web_socket_result
+      @handshake_version = handshake.version if handshake.finished? && handshake.valid?
+    end
+
+    def session_init
+      command(SESSION_INIT, {
+        name: :rb,
+        version: Applitools::VERSION,
+        protocol: :webdriver,
+        cwd: Dir.pwd
+      })
+      # no response
+    end
+
+    def command(name, payload, key = SecureRandom.uuid)
+      json_data = JSON.generate({name: name, key: key, payload: payload})
+      outgoing_frame = WebSocket::Frame::Outgoing::Client.new(version: @handshake_version, data: json_data, type: :text)
+      @web_socket.write(outgoing_frame)
+    end
+
+    def receive_result(name)
+      timeout = 5 * 60 # seconds
+      begin
+        # web_socket_result = @web_socket.recvmsg.first
+        # web_socket_result = @web_socket.read_nonblock(WebSocket.max_frame_size)
+        web_socket_result = @web_socket.readpartial(WebSocket.max_frame_size)
+      rescue IO::WaitReadable
+        if IO.select([@web_socket], nil, nil, timeout)
+          retry
+        else
+          raise Applitools::EyesError.new "Stuck on waiting #{name}"
         end
       end
+      raise Applitools::EyesError.new "Empty result on #{name}" if web_socket_result.empty?
+
+      web_socket_result += receive_result(name) if @web_socket.ready?
+      web_socket_result
+    end
+
+    def format_result(name, key, web_socket_result)
+      encoded_frame = WebSocket::Frame::Incoming::Client.new(version: @handshake_version)
+      encoded_frame << web_socket_result
+      decoded_frame = encoded_frame.next
+      incoming_json = JSON.parse(decoded_frame.to_s)
+      if incoming_json['name'] === 'Server.log'
+        incoming_payload = incoming_json['payload']
+        # incoming_payload['level']
+        puts incoming_payload['message']
+        new_web_socket_result = receive_result(name)
+        result = format_result(name, key, new_web_socket_result)
+      elsif  incoming_json['name'] === name && incoming_json['key'] === key
+        incoming_payload = incoming_json['payload']
+        result = incoming_payload.key?('error') ? incoming_payload['error'] : incoming_payload['result']
+        Applitools::Utils.deep_symbolize_keys result
+      elsif incoming_json.nil?
+        raise Applitools::EyesError.new "Result nil : #{name} #{key} (#{decoded_frame} #{encoded_frame})"
+      else
+        # require 'pry'
+        # binding.pry
+        raise Applitools::EyesError.new "Result mismatch : #{name} #{key} (#{incoming_json['name']} #{incoming_json['key']})"
+      end
     end
 
-    def await(function)
-      resolved = false
-      cb = ->(result) {
-        resolved = result
-      }
-      @queue.push(function)
-      @queue.pop {|fn| fn.call(cb)}
-      sleep 1 until !!resolved
-      resolved
+    def command_with_result name, payload, key = SecureRandom.uuid
+      command(name, payload, key)
+      web_socket_result = receive_result(name)
+      format_result(name, key, web_socket_result)
     end
 
   end

data/lib/applitools/universal_sdk/universal_client_socket.rb

@@ -1,110 +1,129 @@
 # frozen_string_literal: true
 
-require 'faye/websocket'
-require 'json'
-require 'securerandom'
-require 'colorize'
-
-module Applitools::Connectivity
-  class UniversalClientSocket
-    attr_reader :listeners, :queue
-
-    def initialize
-      @listeners = {}
-      @queue = []
-    end
-
-    def connect(uri, ws = ::Faye::WebSocket::Client.new(uri))
-      @socket = ws
-
-      queue.each {|command| command.call}
-      queue.clear
-
-      ws.on :message do |event|
-        message = JSON.parse(event.data, {:symbolize_names => true})
-        params = [message[:payload], message[:key]]
-        find_and_execute_listeners(message[:name], message[:key], params)
-      end
-
-      ws.on :close do |event|
-        find_and_execute_listeners('close')
-      end
-    end
-
-    def emit(message, payload)
-      command = ->() {@socket.send(serialize(message, payload))}
-      @socket ? command.call : queue.push(command)
-    end
-
-    def command(name, fn)
-      on(name, ->(payload, key) {
-        begin
-          log("[#{'COMMAND'.yellow}] #{name}, #{key}, #{JSON.pretty_generate(payload)}")
-          result = fn.call(payload)
-          emit({name: name, key: key}, {result: result})
-        rescue => error
-          log("[#{'COMMAND ERROR'.red}] #{error}")
-          emit({name: name, key: key}, error.message || error)
-        end
-      })
-    end
-
-    def request(name, payload, cb = nil, key = SecureRandom.uuid)
-      log("[#{'REQUEST'.blue}] #{name}, #{key}, #{JSON.pretty_generate(payload)}")
-      emit({name: name, key: key}, payload)
-      once({name: name, key: key}, Proc.new {|result|
-        cb.call(result[:result] || result[:error] || true) if cb
-      })
-    end
-
-    private
-
-    def find_and_execute_listeners(name, key = nil, params = [])
-      name_with_key = "#{name}/#{key}"
-      fns = listeners[name.to_sym]
-      fns = listeners[name_with_key.to_sym] if (!fns)
-      return if (!fns)
-      fns.each {|fn| fn.call(*params)}
-    end
-
-    def serialize(type, payload)
-      message = type.is_a?(String) ?
-        {:name => type, :payload => payload} : {:name => type[:name], key: type[:key], :payload => payload}
-      JSON.generate(message)
-    end
-
-    def get_name_from_type(type)
-      type.is_a?(String) ? type : "#{type[:name]}/#{type[:key]}"
-    end
-
-    def on(type, fn)
-      name = get_name_from_type(type)
-      fns = listeners[name.to_sym]
-      if (!fns)
-        fns = []
-        listeners[name.to_sym] = fns
-      end
-      fns.push(fn)
-    end
-
-    def off(type)
-      name = get_name_from_type(type)
-      listeners.delete(name.to_sym)
-    end
-
-    def once(type, fn)
-      on(type, ->(*args) {
-        fn.call(*args)
-        off(type)
-      })
-    end
-
-    def log(message)
-      if ENV['APPLITOOLS_SHOW_UNIVERSAL_LOGS']
-        Applitools::EyesLogger.logger.debug message
-      end
-    end
-
-  end
-end
-# U-Notes : Added internal Applitools::Connectivity::UniversalClientSocket
+# require 'json'
+# require 'securerandom'
+# require 'colorize'
+# require 'websocket/driver'
+# require 'uri'
+#
+# module Applitools::Connectivity
+#   class UniversalClientSocket
+#     attr_reader :listeners, :queue
+#
+#     def initialize
+#       @listeners = {}
+#       @queue = []
+#     end
+#
+#     attr_reader :url
+#
+#     def write(data)
+#       @socket.write(data)
+#     end
+#
+#
+#     def connect(url)
+#       @url = url
+#       @uri = URI.parse(url)
+#       @socket = TCPSocket.new(@uri.host, @uri.port)
+#
+#       @dead = false
+#       @driver = WebSocket::Driver.client(self)
+#
+#       @driver.on :message do |event|
+#         message = JSON.parse(event.data, {:symbolize_names => true})
+#         params = [message[:payload], message[:key]]
+#         find_and_execute_listeners(message[:name], message[:key], params)
+#       end
+#
+#       @driver.on :close do |event|
+#         find_and_execute_listeners('close')
+#       end
+#       # driver.on(:open) {|event| on_open(event) }
+#       # driver.on(:message) {|event| on_message(event) }
+#       # driver.on(:error) {|event| on_error(event) }
+#       # driver.on(:close) {|event| on_close(event) }
+#
+#       @thread = Thread.new do
+#         @driver.start
+#         @driver.parse(@socket.read(1)) until @dead
+#       end
+#     end
+#
+#     def emit(message, payload)
+#       command = ->() { @driver.text(serialize(message, payload)) }
+#       command.call
+#     end
+#
+#     def command(name, fn)
+#       on(name, ->(payload, key) {
+#         begin
+#           log("[#{'COMMAND'.yellow}] #{name}, #{key}, #{JSON.pretty_generate(payload)}")
+#           result = fn.call(payload)
+#           emit({name: name, key: key}, {result: result})
+#         rescue => error
+#           log("[#{'COMMAND ERROR'.red}] #{error}")
+#           emit({name: name, key: key}, error.message || error)
+#         end
+#       })
+#     end
+#
+#     def request(name, payload, cb = nil, key = SecureRandom.uuid)
+#       log("[#{'REQUEST'.blue}] #{name}, #{key}, #{JSON.pretty_generate(payload)}")
+#       emit({name: name, key: key}, payload)
+#       once({name: name, key: key}, Proc.new {|result|
+#         cb.call(result[:result] || result[:error] || true) if cb
+#       })
+#     end
+#
+#     private
+#
+#     def find_and_execute_listeners(name, key = nil, params = [])
+#       name_with_key = "#{name}/#{key}"
+#       fns = listeners[name.to_sym]
+#       fns = listeners[name_with_key.to_sym] if (!fns)
+#       return if (!fns)
+#       fns.each {|fn| fn.call(*params)}
+#     end
+#
+#     def serialize(type, payload)
+#       message = type.is_a?(String) ?
+#         {:name => type, :payload => payload} : {:name => type[:name], key: type[:key], :payload => payload}
+#       JSON.generate(message)
+#     end
+#
+#     def get_name_from_type(type)
+#       type.is_a?(String) ? type : "#{type[:name]}/#{type[:key]}"
+#     end
+#
+#     def on(type, fn)
+#       name = get_name_from_type(type)
+#       fns = listeners[name.to_sym]
+#       if (!fns)
+#         fns = []
+#         listeners[name.to_sym] = fns
+#       end
+#       fns.push(fn)
+#     end
+#
+#     def off(type)
+#       name = get_name_from_type(type)
+#       listeners.delete(name.to_sym)
+#     end
+#
+#     def once(type, fn)
+#       on(type, ->(*args) {
+#         fn.call(*args)
+#         off(type)
+#       })
+#     end
+#
+#     def log(message)
+#       if ENV['APPLITOOLS_SHOW_UNIVERSAL_LOGS']
+#         Applitools::EyesLogger.logger.debug message
+#       end
+#     end
+#
+#   end
+# end
+# # U-Notes : Added internal Applitools::Connectivity::UniversalClientSocket

data/lib/applitools/universal_sdk/universal_eyes_manager.rb

@@ -19,8 +19,12 @@ module Applitools
 
       @eyes = @universal_client.eyes_manager_make_eyes(@manager, driver_config_json, config)
 
+      if @eyes[:message] === 'socket hang up'
+        Applitools::EyesLogger.logger.error "#{Applitools::Connectivity::UniversalClient::EYES_MANAGER_MAKE_EYES} : socket hang up ; retry"
+        @eyes = @universal_client.eyes_manager_make_eyes(@manager, driver_config_json, config)
+      end
       if @eyes[:message] && @eyes[:stack]
-        Applitools::EyesLogger.logger.debug "Eyes not opened: #{@eyes[:message]}"
+        Applitools::EyesLogger.logger.error "Eyes not opened: #{@eyes[:message]}"
         Applitools::EyesLogger.logger.debug "Stack for #{Applitools::Connectivity::UniversalClient::EYES_MANAGER_MAKE_EYES} : #{@eyes[:stack]}"
         return nil
       end

data/lib/applitools/universal_sdk/universal_server.rb

@@ -16,27 +16,29 @@ module Applitools::Connectivity
     def confirm_is_up(ip, port, attempt = 1)
       raise 'Universal server unavailable' if (attempt === 16)
       begin
-        TCPSocket.new(ip, port)
+        socket = TCPSocket.new(ip, port)
       rescue Errno::ECONNREFUSED
         sleep 1
-        confirm_is_up(ip, port, attempt + 1)
+        socket = confirm_is_up(ip, port, attempt + 1)
       end
+      socket
     end
 
     def check_or_run(ip = DEFAULT_SERVER_IP, port = DEFAULT_SERVER_PORT)
       server_uri = "#{ip}:#{port}"
       socket_uri = "ws://#{server_uri}/eyes"
       begin
-        TCPSocket.new(ip, port)
+        socket = TCPSocket.new(ip, port)
         msg = "Connect to #{server_uri}"
       rescue Errno::ECONNREFUSED
         run
-        confirm_is_up(ip, port)
+        socket = confirm_is_up(ip, port)
         msg = "Connect to #{server_libname} : #{filename}"
       end
 
       Applitools::EyesLogger.logger.debug(msg) if ENV['APPLITOOLS_SHOW_LOGS']
       socket_uri
+      socket
     end
 
     private

data/lib/applitools/utils/utils.rb

@@ -97,6 +97,19 @@ module Applitools::Utils
     end
   end
 
+  def deep_symbolize_keys(value)
+    case value
+      when Hash
+        value.each_with_object({}) do |(key, val), result|
+          result[key.to_sym] = deep_symbolize_keys(val)
+        end
+      when Array
+        value.map { |e| deep_symbolize_keys(e) }
+      else
+        value
+    end
+  end
+
   private
 
   def convert_hash_keys(value, method)

data/lib/applitools/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: false
 
 module Applitools
-  VERSION = '4.0.5.4'.freeze
-  UNIVERSAL_VERSION = '2.7.1'.freeze
+  VERSION = '4.1.1'.freeze
+  UNIVERSAL_VERSION = '2.8.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eyes_core
 version: !ruby/object:Gem::Version
-  version: 4.0.5.4
+  version: 4.1.1
 platform: ruby
 authors:
 - Applitools Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-06-10 00:00:00.000000000 Z
+date: 2022-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -81,21 +81,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: faye-websocket
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: eventmachine
+  name: websocket
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -128,14 +114,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.7.1
+        version: 2.8.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.7.1
+        version: 2.8.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement