eyes_selenium 3.14.10 → 3.15.0.beta

data/lib/applitools/selenium/visual_grid/running_test.rb

@@ -0,0 +1,198 @@
+require 'state_machine'
+require 'digest'
+
+module Applitools
+  module Selenium
+    class RunningTest
+      extend Forwardable
+      def_delegators 'Applitools::EyesLogger', :logger, :log_handler, :log_handler=
+
+      state_machine :initial => :new do
+        state :new do
+          def close
+            becomes_completed
+          end
+
+          def score
+            0
+          end
+
+          def queue
+            Applitools::Selenium::VisualGridRunner::EMPTY_QUEUE
+          end
+        end
+
+        state :not_rendered do
+          def score
+            render_queue.length * 10
+          end
+
+          def queue
+            render_queue
+          end
+        end
+
+        state :opened do
+          def score
+            task_queue.length
+          end
+
+          def queue
+            return Applitools::Selenium::VisualGridRunner::EMPTY_QUEUE unless task_lock.nil?
+            self.task_lock = task_queue.last unless task_queue.last.nil?
+            task_queue
+          end
+        end
+
+        state :rendered do
+          def score
+            open_queue.length
+          end
+
+          def queue
+            open_queue
+          end
+        end
+
+        state :tested do
+          def score
+            close_queue.length
+          end
+
+          def queue
+            close_queue
+          end
+        end
+
+        state :completed do
+          def score
+            0
+          end
+
+          def queue
+            Applitools::Selenium::VisualGridRunner::EMPTY_QUEUE
+          end
+        end
+
+        state :new, :not_rendered, :opened, :rendered, :tested do
+          def close
+            self.test_result = nil
+            close_task = Applitools::Selenium::VGTask.new("close #{browser_info}") do
+              eyes.close(false)
+            end
+            close_task.on_task_succeeded do |task_result|
+              self.test_result = task_result
+            end.on_task_error do |e|
+              self.pending_exceptions << e
+            end.on_task_completed do
+              watch_close[close_task] = true
+              becomes_completed if all_tasks_completed?(watch_close)
+            end
+            close_queue << close_task
+            watch_close[close_task] = false
+          end
+        end
+
+        event :becomes_not_rendered do
+          transition :new => :not_rendered
+        end
+
+        event :becomes_opened do
+          transition :rendered => :opened
+        end
+
+        event :becomes_rendered do
+          transition :not_rendered => :rendered
+        end
+
+        event :becomes_tested do
+          transition :opened => :tested
+        end
+
+        event :becomes_completed do
+          transition [:not_rendered, :rendered, :opened, :tested] => :completed
+        end
+      end
+
+      attr_accessor :open_queue, :task_queue, :render_queue, :close_queue, :watch_open, :watch_task, :watch_render, :watch_close
+
+      attr_accessor :eyes, :browser_info, :test_result, :pending_exceptions, :driver, :task_lock
+
+      def initialize(eyes, browser_info, driver)
+        Applitools::ArgumentGuard.is_a? eyes, 'eyes', Applitools::Selenium::EyesConnector
+        Applitools::ArgumentGuard.is_a? browser_info, 'browser_info', Applitools::Selenium::RenderBrowserInfo
+
+        self.eyes = eyes
+        self.browser_info = browser_info
+        self.driver = driver
+
+        self.open_queue = []
+        self.task_queue = []
+        self.render_queue = []
+        self.close_queue = []
+
+        self.watch_open = {}
+        self.watch_task = {}
+        self.watch_render = {}
+        self.watch_close = {}
+
+        self.task_lock = nil
+
+        self.pending_exceptions = []
+        super()
+        init
+      end
+
+      def init
+        open_task = Applitools::Selenium::VGTask.new("open #{browser_info}") { eyes.open(driver, browser_info) }
+
+        open_task.on_task_succeeded { watch_open[open_task] = true; becomes_opened if all_tasks_completed?(watch_open) }.
+            on_task_error { |e| pending_exceptions << e; becomes_completed }
+        open_queue << open_task
+        watch_open[open_task] = false
+      end
+
+      def check(tag, target, script_result, visual_grid_manager, mod = nil)
+        render_task = RenderTask.new(
+          "Render #{eyes.config.short_description} - #{tag}",
+          script_result,
+          self,
+          visual_grid_manager.resource_cache,
+          visual_grid_manager.put_cache,
+          visual_grid_manager.rendering_info(eyes.server_connector),
+          eyes.server_connector,
+          mod
+        )
+
+        check_task = VGTask.new("perform check #{tag} #{target}") do
+          eyes.check(tag, target, render_task.uuid)
+        end
+
+        check_task.on_task_completed do
+          watch_task[check_task] = true
+          self.task_lock = nil if task_lock.uuid == check_task.uuid
+          becomes_tested if all_tasks_completed?(watch_task)
+        end
+
+        task_queue.insert(0, check_task)
+        watch_task[check_task] = false
+
+        render_task.on_task_succeeded do |r|
+          eyes.render_status_for_task(render_task.uuid, r) if r
+          watch_render[render_task] = true
+          becomes_rendered if all_tasks_completed?(watch_render)
+        end.on_task_error do
+          becomes_completed
+        end
+        render_queue << render_task
+        watch_render[render_task] = false
+      end
+
+      def all_tasks_completed?(watch)
+        return true if state_name == :completed
+        uniq_values = watch.values.uniq
+        uniq_values.count == 1 && uniq_values.first == true
+      end
+    end
+  end
+end

data/lib/applitools/selenium/visual_grid/thread_pool.rb

@@ -0,0 +1,94 @@
+require 'thread'
+
+module Applitools
+  module Selenium
+    class VGThreadPool
+      extend Forwardable
+      attr_accessor :concurrency
+      def_delegator 'Applitools::EyesLogger', :logger
+
+      def initialize(concurrency = 10)
+        self.concurrency = concurrency
+        @stopped = true
+        @thread_group = ThreadGroup.new
+        @semaphore = Mutex.new
+        @next_task_block = nil
+        @watchdog = nil
+      end
+
+      def on_next_task_needed(&block)
+        @next_task_block = block if block_given?
+      end
+
+      def start
+        @semaphore.synchronize { @stopped = false }
+        init_or_renew_threads
+        @watchdog = Thread.new do
+          catch(:exit) do
+            loop do
+              throw :exit if stopped?
+              sleep 5
+              init_or_renew_threads
+            end
+          end
+        end
+      end
+
+      def stop
+        @watchdog.exit
+        @semaphore.synchronize do
+          @stopped = true
+        end
+        @thread_group.list.each do |t|
+          t.join
+        end
+        stopped?
+      end
+
+      def stopped?
+        @semaphore.synchronize { @stopped }
+      end
+
+      private
+
+      def next_task
+        @semaphore.synchronize do
+          return @next_task_block.call if @next_task_block && @next_task_block.respond_to?(:call)
+        end
+        nil
+      end
+
+      def init_or_renew_threads
+        (concurrency - @thread_group.list.count).times do
+          logger.debug 'starting new thread (task worker)'
+          next_thread
+        end
+      end
+
+      def next_thread
+        thread = Thread.new do
+          begin
+            catch(:exit) do
+              loop do
+                throw :exit if stopped?
+                task_to_run = next_task
+                if task_to_run && task_to_run.respond_to?(:call)
+                  logger.debug "Executing new task... #{task_to_run.name}"
+                  task_to_run.call
+                  logger.debug 'Done!'
+                else
+                  sleep 0.5
+                end
+              end
+            end
+          rescue => e
+            Applitools::EyesLogger.logger.error "Failed to execute task - #{task_to_run.name}"
+            Applitools::EyesLogger.logger.error e.message
+            Applitools::EyesLogger.logger.error e.backtrace.join( ' ')
+          end
+        end
+        @thread_group.add thread
+      end
+    end
+  end
+end

data/lib/applitools/selenium/visual_grid/vg_resource.rb

@@ -0,0 +1,37 @@
+require 'base64'
+require 'digest'
+module Applitools
+  module Selenium
+    class VGResource
+      include Applitools::Jsonable
+      json_fields :contentType, :hash, :hashFormat
+      attr_accessor :url, :content
+      alias :content_type :contentType
+      alias :content_type= :contentType=
+
+      class << self
+        def parse_blob_from_script(blob)
+          content = Base64.decode64(blob["value"])
+          self.new blob["url"], blob["type"], content
+        end
+
+        def parse_response(url, response)
+          return self.new(url, 'application/empty-response', '') unless response.status == 200
+          self.new(url, response.headers['Content-Type'], response.body)
+        end
+      end
+
+      def initialize(url, content_type, content)
+        self.url = URI(url)
+        self.content_type = content_type
+        self.content = content
+        self.hash = Digest::SHA256.hexdigest(content)
+        self.hashFormat = 'sha256'
+      end
+
+      def stringify
+        url.to_s + content_type.to_s + hash
+      end
+    end
+  end
+end

data/lib/applitools/selenium/visual_grid/vg_task.rb

@@ -0,0 +1,46 @@
+require 'securerandom'
+module Applitools
+  module Selenium
+    class VGTask
+      attr_accessor :name, :uuid
+      def initialize(name, &block)
+        self.name = name
+        @block_to_run = block if block_given?
+        @callback = nil
+        @error_callback = nil
+        @completed_callback = nil
+        self.uuid = SecureRandom.uuid
+      end
+
+      def on_task_succeeded(&block)
+        @callback = block if block_given?
+        self
+      end
+
+      def on_task_error(&block)
+        @error_callback = block if block_given?
+        self
+      end
+
+      def on_task_completed(&block)
+        @completed_callback = block if block_given?
+        self
+      end
+
+      def call
+        return unless @block_to_run.respond_to? :call
+        begin
+          res = @block_to_run.call
+          @callback.call(res) if @callback.respond_to? :call
+        rescue StandardError => e
+          Applitools::EyesLogger.logger.error 'Failed to execute task!'
+          Applitools::EyesLogger.logger.error e.message
+          Applitools::EyesLogger.logger.error e.backtrace.join('\n\t')
+          @error_callback.call(e) if @error_callback.respond_to? :call
+        ensure
+          @completed_callback.call if @completed_callback.respond_to? :call
+        end
+      end
+    end
+  end
+end

data/lib/applitools/selenium/visual_grid/visual_grid_eyes.rb

@@ -0,0 +1,236 @@
+require 'applitools/selenium/selenium_configuration'
+module Applitools
+  module Selenium
+    class VisualGridEyes
+      extend Forwardable
+
+      def_delegators 'Applitools::EyesLogger', :logger, :log_handler, :log_handler=
+
+      attr_accessor :visual_grid_manager, :driver, :current_url, :current_config, :fetched_cache_map, :config
+      attr_accessor :test_list
+
+      attr_accessor :api_key, :server_url, :proxy, :opened
+
+      def_delegators 'config', *Applitools::Selenium::SeleniumConfiguration.methods_to_delegate
+      def_delegators 'config', *Applitools::EyesBaseConfiguration.methods_to_delegate
+
+      def initialize(visual_grid_manager, server_url = nil)
+        ensure_config
+        self.visual_grid_manager = visual_grid_manager
+        self.test_list = Applitools::Selenium::TestList.new
+        self.opened = false
+      end
+
+      def ensure_config
+        self.config = Applitools::Selenium::SeleniumConfiguration.new
+      end
+
+
+      def open(*args)
+        self.test_list = Applitools::Selenium::TestList.new
+        options = Applitools::Utils.extract_options!(args)
+        Applitools::ArgumentGuard.hash(options, 'options', [:driver])
+
+        # self.current_config = options.delete(:config)
+        # self.current_config = yield(Applitools::Selenium::SeleniumConfiguration.new) if block_given?
+
+        # Applitools::ArgumentGuard.is_a? options[:driver], 'options[:driver]', ::Selenium::WebDriver
+        # Applitools::ArgumentGuard.is_a? current_config, 'options[:config]', Applitools::Selenium::SeleniumConfiguration
+
+        # batch_info.name = config.app_name
+        self.driver = options.delete(:driver)
+        self.current_url = driver.current_url
+
+        visual_grid_manager.open(self)
+
+        logger.info("getting all browsers info...")
+        browsers_info_list = config.browsers_info
+        logger.info("creating test descriptors for each browser info...")
+        browsers_info_list.each do |bi|
+          test_list.push Applitools::Selenium::RunningTest.new(eyes_connector, bi, driver)
+        end
+        self.opened = true
+        driver
+      end
+
+      def eyes_connector
+        logger.info("creating VisualGridEyes server connector")
+        ::Applitools::Selenium::EyesConnector.new(server_url).tap do |connector|
+          connector.batch = batch_info
+          connector.config = config.deep_clone
+          connector.proxy = proxy if proxy.is_a? Applitools::Connectivity::Proxy
+        end
+      end
+
+      def check(tag, target)
+        script = <<-END
+          var callback = arguments[arguments.length - 1]; return (#{Applitools::Selenium::Scripts::PROCESS_RESOURCES})().then(JSON.stringify).then(callback, function(err) {callback(err.stack || err.toString())});
+        END
+
+        script_result = driver.execute_async_script(script).freeze
+        mod = Digest::SHA2.hexdigest(script_result)
+        test_list.each do |test|
+          test.check(tag, target, script_result.dup, visual_grid_manager, mod)
+        end
+        test_list.each { |t| t.becomes_not_rendered}
+      end
+
+      def close(throw_exception = true)
+        return false if test_list.empty?
+        test_list.each do |t|
+          t.close
+        end
+
+        while (!((states = test_list.map(&:state_name).uniq).count == 1 && states.first == :completed)) do
+          sleep 0.5
+        end
+        self.opened = false
+
+        test_list.select { |t| t.pending_exceptions && !t.pending_exceptions.empty? }.each do |t|
+          t.pending_exceptions.each do |e|
+            raise e
+          end
+        end
+
+        if throw_exception
+          test_list.map(&:test_result).compact.each do |r|
+            raise Applitools::NewTestError.new new_test_error_message(r), r if r.new?
+            raise Applitools::DiffsFoundError.new diffs_found_error_message(r), r if r.unresolved? && !r.new?
+            raise Applitools::TestFailedError.new test_failed_error_message(r), r if r.failed?
+          end
+        end
+        test_list.map(&:test_result).first
+      end
+
+      def open?
+        opened
+      end
+
+      def get_all_test_results
+        test_list.map(&:test_result)
+      end
+
+      def new_test_error_message(result)
+        original_results = result.original_results
+        "New test '#{original_results['name']}' " \
+            "of '#{original_results['appName']}' " \
+            "Please approve the baseline at #{original_results['appUrls']['session']} "
+      end
+
+      def diffs_found_error_message(result)
+        original_results = result.original_results
+        "Test '#{original_results['name']}' " \
+            "of '#{original_results['appname']}' " \
+            "detected differences! See details at #{original_results['appUrls']['session']}"
+      end
+
+      def test_failed_error_message(result)
+        original_results = result.original_results
+        "Test '#{original_results['name']}' of '#{original_results['appName']}' " \
+            "is failed! See details at #{original_results['appUrls']['session']}"
+      end
+      private :new_test_error_message, :diffs_found_error_message, :test_failed_error_message
+
+      # Takes a snapshot of the application under test and matches it with the expected output.
+      #
+      # @param [String] tag An optional tag to be assosiated with the snapshot.
+      # @param [Fixnum] match_timeout The amount of time to retry matching (seconds)
+      def check_window(tag = nil, match_timeout = USE_DEFAULT_MATCH_TIMEOUT)
+        target = Applitools::Selenium::Target.window.tap do |t|
+          t.timeout(match_timeout)
+          t.fully if force_full_page_screenshot
+        end
+        check(tag, target)
+      end
+
+      # Takes a snapshot of the application under test and matches a region of
+      # a specific element with the expected region output.
+      #
+      # @param [Applitools::Selenium::Element] element Represents a region to check.
+      # @param [Symbol] how a finder, such :css or :id. Selects a finder will be used to find an element
+      #   See Selenium::Webdriver::Element#find_element documentation for full list of possible finders.
+      # @param [String] what The value will be passed to a specified finder. If finder is :css it must be a css selector.
+      # @param [Hash] options
+      # @option options [String] :tag An optional tag to be associated with the snapshot.
+      # @option options [Fixnum] :match_timeout The amount of time to retry matching. (Seconds)
+      # @option options [Boolean] :stitch_content If set to true, will try to get full content of the element
+      #   (including hidden content due overflow settings) by scrolling the element,
+      #   taking and stitching partial screenshots.
+      # @example Check region by element
+      #   check_region(element, tag: 'Check a region by element', match_timeout: 3, stitch_content: false)
+      # @example Check region by css selector
+      #   check_region(:css, '.form-row .input#e_mail', tag: 'Check a region by element', match_timeout: 3,
+      #   stitch_content: false)
+      # @!parse def check_region(element, how=nil, what=nil, options = {}); end
+      def check_region(*args)
+        options = { timeout: USE_DEFAULT_MATCH_TIMEOUT, tag: nil }.merge! Applitools::Utils.extract_options!(args)
+        target = Applitools::Selenium::Target.new.region(*args).timeout(options[:match_timeout])
+        target.fully if options[:stitch_content]
+        check(options[:tag], target)
+      end
+
+      # Validates the contents of an iframe and matches it with the expected output.
+      #
+      # @param [Hash] options The specific parameters of the desired screenshot.
+      # @option options [Fixnum] :timeout The amount of time to retry matching. (Seconds)
+      # @option options [String] :tag An optional tag to be associated with the snapshot.
+      # @option options [String] :frame Frame element or frame name or frame id.
+      # @option options [String] :name_or_id The name or id of the target frame (deprecated. use :frame instead).
+      # @option options [String] :frame_element The frame element (deprecated. use :frame instead).
+      # @return [Applitools::MatchResult] The match results.
+
+      def check_frame(options = {})
+        options = { timeout: USE_DEFAULT_MATCH_TIMEOUT, tag: nil }.merge!(options)
+        frame = options[:frame] || options[:frame_element] || options[:name_or_id]
+        target = Applitools::Selenium::Target.frame(frame).timeout(options[:timeout]).fully
+        check(options[:tag], target)
+      end
+
+      # Validates the contents of a region in an iframe and matches it with the expected output.
+      #
+      # @param [Hash] options The specific parameters of the desired screenshot.
+      # @option options [String] :name_or_id The name or id of the target frame (deprecated. use :frame instead).
+      # @option options [String] :frame_element The frame element (deprecated. use :frame instead).
+      # @option options [String] :frame Frame element or frame name or frame id.
+      # @option options [String] :tag An optional tag to be associated with the snapshot.
+      # @option options [Symbol] :by By which identifier to find the region (e.g :css, :id).
+      # @option options [Fixnum] :timeout The amount of time to retry matching. (Seconds)
+      # @option options [Boolean] :stitch_content Whether to stitch the content or not.
+      # @return [Applitools::MatchResult] The match results.
+      def check_region_in_frame(options = {})
+        options = { timeout: USE_DEFAULT_MATCH_TIMEOUT, tag: nil, stitch_content: false }.merge!(options)
+        Applitools::ArgumentGuard.not_nil options[:by], 'options[:by]'
+        Applitools::ArgumentGuard.is_a? options[:by], 'options[:by]', Array
+
+        how_what = options.delete(:by)
+        frame = options[:frame] || options[:frame_element] || options[:name_or_id]
+
+        target = Applitools::Selenium::Target.new.timeout(options[:timeout])
+        target.frame(frame) if frame
+        target.fully if options[:stitch_content]
+        target.region(*how_what)
+
+        check(options[:tag], target)
+      end
+
+      # Use this method to perform seamless testing with selenium through eyes driver.
+      # It yields a block and passes to it an Applitools::Selenium::Driver instance, which wraps standard driver.
+      # Using Selenium methods inside the 'test' block will send the messages to Selenium
+      # after creating the Eyes triggers for them. Options are similar to {open}
+      # @yieldparam driver [Applitools::Selenium::Driver] Gives a driver to a block, which translates calls to a native
+      #   Selemium::Driver instance
+      # @example
+      #   eyes.test(app_name: 'my app', test_name: 'my test') do |driver|
+      #      driver.get "http://www.google.com"
+      #      driver.check_window("initial")
+      #   end
+      def test(options = {}, &_block)
+        open(options)
+        yield(driver)
+        close
+      ensure
+        abort_if_not_closed
+      end
+    end
+  end
+end