chemlab 0.0.1

data/qa/support/api.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module QA
+  module Support
+    module Api
+      HTTP_STATUS_OK = 200
+      HTTP_STATUS_CREATED = 201
+      HTTP_STATUS_NO_CONTENT = 204
+      HTTP_STATUS_ACCEPTED = 202
+      HTTP_STATUS_SERVER_ERROR = 500
+
+      def post(url, payload)
+        RestClient::Request.execute(
+          method: :post,
+          url: url,
+          payload: payload,
+          verify_ssl: false)
+      rescue RestClient::ExceptionWithResponse => e
+        return_response_or_raise(e)
+      end
+
+      def get(url, raw_response: false)
+        RestClient::Request.execute(
+          method: :get,
+          url: url,
+          verify_ssl: false,
+          raw_response: raw_response)
+      rescue RestClient::ExceptionWithResponse => e
+        return_response_or_raise(e)
+      end
+
+      def put(url, payload)
+        RestClient::Request.execute(
+          method: :put,
+          url: url,
+          payload: payload,
+          verify_ssl: false)
+      rescue RestClient::ExceptionWithResponse => e
+        return_response_or_raise(e)
+      end
+
+      def delete(url)
+        RestClient::Request.execute(
+          method: :delete,
+          url: url,
+          verify_ssl: false)
+      rescue RestClient::ExceptionWithResponse => e
+        return_response_or_raise(e)
+      end
+
+      def head(url)
+        RestClient::Request.execute(
+          method: :head,
+          url: url,
+          verify_ssl: false)
+      rescue RestClient::ExceptionWithResponse => e
+        return_response_or_raise(e)
+      end
+
+      def parse_body(response)
+        JSON.parse(response.body, symbolize_names: true)
+      end
+
+      def return_response_or_raise(error)
+        raise error unless error.respond_to?(:response) && error.response
+
+        error.response
+      end
+    end
+  end
+end

data/qa/support/dates.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module QA
+  module Support
+    module Dates
+      def current_date_yyyy_mm_dd
+        current_date.strftime("%Y/%m/%d")
+      end
+
+      def next_month_yyyy_mm_dd
+        current_date.next_month.strftime("%Y/%m/%d")
+      end
+
+      private
+
+      def current_date
+        DateTime.now
+      end
+    end
+  end
+end

data/qa/support/page/logging.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module QA
+  module Support
+    module Page
+      module Logging
+        def assert_no_element(name)
+          log("asserting no element :#{name}")
+
+          super
+        end
+
+        def refresh
+          log("refreshing #{current_url}")
+
+          super
+        end
+
+        def scroll_to(selector, text: nil)
+          msg = "scrolling to :#{selector}"
+          msg += " with text: #{text}" if text
+          log(msg)
+
+          super
+        end
+
+        def asset_exists?(url)
+          exists = super
+
+          log("asset_exists? #{url} returned #{exists}")
+
+          exists
+        end
+
+        def find_element(name, **kwargs)
+          log("finding :#{name} with args #{kwargs}")
+
+          element = super
+
+          log("found :#{name}") if element
+
+          element
+        end
+
+        def all_elements(name, **kwargs)
+          log("finding all :#{name} with args #{kwargs}")
+
+          elements = super
+
+          log("found #{elements.size} :#{name}") if elements
+
+          elements
+        end
+
+        def check_element(name)
+          log("checking :#{name}")
+
+          super
+        end
+
+        def uncheck_element(name)
+          log("unchecking :#{name}")
+
+          super
+        end
+
+        def click_element(name, page = nil, **kwargs)
+          msg = ["clicking :#{name}"]
+          msg << ", expecting to be at #{page.class}" if page
+          msg << "with args #{kwargs}"
+
+          log(msg.compact.join(' '))
+
+          super
+        end
+
+        def fill_element(name, content)
+          masked_content = name.to_s.include?('password') ? '*****' : content
+
+          log(%Q(filling :#{name} with "#{masked_content}"))
+
+          super
+        end
+
+        def select_element(name, value)
+          log(%Q(selecting "#{value}" in :#{name}))
+
+          super
+        end
+
+        def has_element?(name, **kwargs)
+          found = super
+
+          log_has_element_or_not('has_element?', name, found, **kwargs)
+
+          found
+        end
+
+        def has_no_element?(name, **kwargs)
+          found = super
+
+          log_has_element_or_not('has_no_element?', name, found, **kwargs)
+
+          found
+        end
+
+        def has_text?(text, **kwargs)
+          found = super
+
+          log(%Q{has_text?('#{text}', wait: #{kwargs[:wait] || Capybara.default_max_wait_time}) returned #{found}})
+
+          found
+        end
+
+        def has_no_text?(text, **kwargs)
+          found = super
+
+          log(%Q{has_no_text?('#{text}', wait: #{kwargs[:wait] || Capybara.default_max_wait_time}) returned #{found}})
+
+          found
+        end
+
+        def finished_loading?
+          log('waiting for loading to complete...')
+          now = Time.now
+
+          loaded = super
+
+          log("loading complete after #{Time.now - now} seconds")
+
+          loaded
+        end
+
+        def wait_for_animated_element(name)
+          log("waiting for animated element: #{name}")
+
+          super
+        end
+
+        def within_element(name, text: nil)
+          log("within element :#{name}")
+
+          element = super
+
+          log("end within element :#{name}")
+
+          element
+        end
+
+        def within_element_by_index(name, index)
+          log("within elements :#{name} at index #{index}")
+
+          element = super
+
+          log("end within elements :#{name} at index #{index}")
+
+          element
+        end
+
+        private
+
+        def log(msg)
+          QA::Runtime::Logger.debug(msg)
+        end
+
+        def log_has_element_or_not(method, name, found, **kwargs)
+          msg = ["#{method} :#{name}"]
+          msg << %Q(with text "#{kwargs[:text]}") if kwargs[:text]
+          msg << "class: #{kwargs[:class]}" if kwargs[:class]
+          msg << "(wait: #{kwargs[:wait] || Capybara.default_max_wait_time})"
+          msg << "returned: #{found}"
+
+          log(msg.compact.join(' '))
+        end
+      end
+    end
+  end
+end

data/qa/support/repeater.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'active_support/inflector'
+
+module QA
+  module Support
+    module Repeater
+      DEFAULT_MAX_WAIT_TIME = 60
+
+      RetriesExceededError = Class.new(RuntimeError)
+      WaitExceededError = Class.new(RuntimeError)
+
+      def repeat_until(max_attempts: nil, max_duration: nil, reload_page: nil, sleep_interval: 0, raise_on_failure: true, retry_on_exception: false, log: true)
+        attempts = 0
+        start = Time.now
+
+        begin
+          while remaining_attempts?(attempts, max_attempts) && remaining_time?(start, max_duration)
+            QA::Runtime::Logger.debug("Attempt number #{attempts + 1}") if max_attempts && log
+
+            result = yield
+            return result if result
+
+            sleep_and_reload_if_needed(sleep_interval, reload_page)
+            attempts += 1
+          end
+        rescue StandardError, RSpec::Expectations::ExpectationNotMetError
+          raise unless retry_on_exception
+
+          attempts += 1
+          if remaining_attempts?(attempts, max_attempts) && remaining_time?(start, max_duration)
+            sleep_and_reload_if_needed(sleep_interval, reload_page)
+
+            retry
+          else
+            raise
+          end
+        end
+
+        if raise_on_failure
+          raise RetriesExceededError, "Retry condition not met after #{max_attempts} #{'attempt'.pluralize(max_attempts)}" unless remaining_attempts?(attempts, max_attempts)
+
+          raise WaitExceededError, "Wait condition not met after #{max_duration} #{'second'.pluralize(max_duration)}"
+        end
+
+        false
+      end
+
+      private
+
+      def sleep_and_reload_if_needed(sleep_interval, reload_page)
+        sleep(sleep_interval)
+        reload_page.refresh if reload_page
+      end
+
+      def remaining_attempts?(attempts, max_attempts)
+        max_attempts ? attempts < max_attempts : true
+      end
+
+      def remaining_time?(start, max_duration)
+        max_duration ? Time.now - start < max_duration : true
+      end
+    end
+  end
+end

data/qa/support/retrier.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module QA
+  module Support
+    module Retrier
+      extend Repeater
+
+      module_function
+
+      def retry_on_exception(max_attempts: 3, reload_page: nil, sleep_interval: 0.5)
+        QA::Runtime::Logger.debug(
+          <<~MSG.tr("\n", ' ')
+            with retry_on_exception: max_attempts: #{max_attempts};
+            reload_page: #{reload_page};
+            sleep_interval: #{sleep_interval}
+        MSG
+        )
+
+        result = nil
+        repeat_until(
+          max_attempts: max_attempts,
+          reload_page: reload_page,
+          sleep_interval: sleep_interval,
+          retry_on_exception: true
+        ) do
+          result = yield
+
+          # This method doesn't care what the return value of the block is.
+          # We set it to `true` so that it doesn't repeat if there's no exception
+          true
+        end
+        QA::Runtime::Logger.debug("ended retry_on_exception")
+
+        result
+      end
+
+      def retry_until(max_attempts: nil, max_duration: nil, reload_page: nil, sleep_interval: 0, raise_on_failure: true, retry_on_exception: false)
+        # For backwards-compatibility
+        max_attempts = 3 if max_attempts.nil? && max_duration.nil?
+
+        start_msg ||= ["with retry_until:"]
+        start_msg << "max_attempts: #{max_attempts};" if max_attempts
+        start_msg << "max_duration: #{max_duration};" if max_duration
+        start_msg << "reload_page: #{reload_page}; sleep_interval: #{sleep_interval}; raise_on_failure: #{raise_on_failure}; retry_on_exception: #{retry_on_exception}"
+        QA::Runtime::Logger.debug(start_msg.join(' '))
+
+        result = nil
+        repeat_until(
+          max_attempts: max_attempts,
+          max_duration: max_duration,
+          reload_page: reload_page,
+          sleep_interval: sleep_interval,
+          raise_on_failure: raise_on_failure,
+          retry_on_exception: retry_on_exception
+        ) do
+          result = yield
+        end
+        QA::Runtime::Logger.debug("ended retry_until")
+
+        result
+      end
+    end
+  end
+end

data/qa/support/wait_for_requests.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module QA
+  module Support
+    module WaitForRequests
+      module_function
+
+      def wait_for_requests
+        Waiter.wait_until(log: false) do
+          finished_all_ajax_requests? && finished_all_axios_requests?
+        end
+      end
+
+      def finished_all_axios_requests?
+        Capybara.page.evaluate_script('window.pendingRequests || 0').zero?
+      end
+
+      def finished_all_ajax_requests?
+        return true if Capybara.page.evaluate_script('typeof jQuery === "undefined"')
+
+        Capybara.page.evaluate_script('jQuery.active').zero?
+      end
+    end
+  end
+end

data/qa/support/waiter.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module QA
+  module Support
+    module Waiter
+      extend Repeater
+
+      module_function
+
+      def wait_until(max_duration: singleton_class::DEFAULT_MAX_WAIT_TIME, reload_page: nil, sleep_interval: 0.1, raise_on_failure: true, retry_on_exception: false, log: true)
+        if log
+          QA::Runtime::Logger.debug(
+            <<~MSG.tr("\n", ' ')
+              with wait_until: max_duration: #{max_duration};
+              reload_page: #{reload_page};
+              sleep_interval: #{sleep_interval};
+              raise_on_failure: #{raise_on_failure}
+            MSG
+          )
+        end
+
+        result = nil
+        self.repeat_until(
+          max_duration: max_duration,
+          reload_page: reload_page,
+          sleep_interval: sleep_interval,
+          raise_on_failure: raise_on_failure,
+          retry_on_exception: retry_on_exception,
+          log: log
+        ) do
+          result = yield
+        end
+        QA::Runtime::Logger.debug("ended wait_until") if log
+
+        result
+      end
+    end
+  end
+end