howitzer 2.0.3 → 2.3.0

data/lib/howitzer/mail_adapters/gmail.rb

@@ -0,0 +1,96 @@
+require 'howitzer/exceptions'
+require 'howitzer/mail_adapters/abstract'
+require 'howitzer/gmail_api/client'
+
+module Howitzer
+  module MailAdapters
+    # This class represents Gmail mail adapter
+    class Gmail < Abstract
+      # Finds an email in storage
+      # @param recipient [String] an email
+      # @param subject [String]
+      # @param wait [Integer] how much time is required to wait an email
+      # @raise [EmailNotFoundError] if blank message
+
+      def self.find(recipient, subject, wait:)
+        message = {}
+        retryable(find_retry_params(wait)) { message = get_message(recipient, subject) }
+        return new(message) if message.present?
+
+        raise Howitzer::EmailNotFoundError,
+              "Message with subject '#{subject}' for recipient '#{recipient}' was not found."
+      end
+
+      # @return [String] plain text body of the email message
+
+      def plain_text_body
+        message.body.to_s
+      end
+
+      # @return [String] html body of the email message
+
+      def html_body
+        message.html_part.to_s
+      end
+
+      # @return [String] stripped text
+
+      def text
+        message.text_part.to_s
+      end
+
+      # @return [String] an email address specified in `From` field
+
+      def mail_from
+        "#{message.from[0]['mailbox']}@#{message.from[0]['host']}"
+      end
+
+      # @return [Array] recipient emails
+
+      def recipients
+        message.to.inject([]) { |ar, to| ar << "#{to['mailbox']}@#{to['host']}" }
+      end
+
+      # @return [String] when email was received
+
+      def received_time
+        Time.parse(message.date).strftime('%F %T')
+      end
+
+      # @return [Array] attachments
+
+      def mime_part
+        message.attachments
+      end
+
+      # @raise [NoAttachmentsError] if no attachments present
+      # @return [Array] attachments
+
+      def mime_part!
+        files = mime_part
+        return files if files.present?
+
+        raise Howitzer::NoAttachmentsError, 'No attachments were found.'
+      end
+
+      def self.get_message(recipient, subject)
+        message = Howitzer::GmailApi::Client.new.find_message(recipient, subject)
+        raise Howitzer::EmailNotFoundError if message.blank?
+
+        message
+      end
+      private_class_method :get_message
+
+      def self.find_retry_params(wait)
+        {
+          timeout: wait,
+          sleep: Howitzer.mail_sleep_time,
+          silent: true,
+          logger: Howitzer::Log,
+          on: Howitzer::EmailNotFoundError
+        }
+      end
+      private_class_method :find_retry_params
+    end
+  end
+end

data/lib/howitzer/mail_adapters/mailgun.rb

@@ -17,6 +17,7 @@ module Howitzer
         message = {}
         retryable(find_retry_params(wait)) { message = retrieve_message(recipient, subject) }
         return new(message) if message.present?
+
         raise Howitzer::EmailNotFoundError,
               "Message with subject '#{subject}' for recipient '#{recipient}' was not found."
       end
@@ -75,7 +76,8 @@ module Howitzer
       def mime_part!
         files = mime_part
         return files if files.present?
-        raise Howitzer::NoAttachmentsError, 'No attachments where found.'
+
+        raise Howitzer::NoAttachmentsError, 'No attachments were found.'
       end
 
       def self.events
@@ -95,7 +97,7 @@ module Howitzer
       def self.find_retry_params(wait)
         {
           timeout: wait || Howitzer.try(:mailgun_idle_timeout),
-          sleep: Howitzer.mailgun_sleep_time,
+          sleep: Howitzer.mail_sleep_time || Howitzer.mailgun_sleep_time,
           silent: true,
           logger: Howitzer::Log,
           on: Howitzer::EmailNotFoundError

data/lib/howitzer/mail_adapters/mailtrap.rb

@@ -0,0 +1,108 @@
+require 'howitzer/exceptions'
+require 'howitzer/mail_adapters/abstract'
+require 'howitzer/mailtrap_api/client'
+
+module Howitzer
+  module MailAdapters
+    # This class represents mailtrap mail adapter
+    class Mailtrap < Abstract
+      # Finds an email in storage
+      # @param recipient [String] an email
+      # @param subject [String]
+      # @param wait [Integer] how much time is required to wait an email
+      # @raise [EmailNotFoundError] if blank message
+
+      def self.find(recipient, subject, wait:)
+        message = {}
+        retryable(find_retry_params(wait)) { message = retrieve_message(recipient, subject) }
+        return new(message) if message.present?
+
+        raise Howitzer::EmailNotFoundError,
+              "Message with subject '#{subject}' for recipient '#{recipient}' was not found."
+      end
+
+      # @return [String] plain text body of the email message
+
+      def plain_text_body
+        message['text_body']
+      end
+
+      # @return [String] html body of the email message
+
+      def html_body
+        message['html_body']
+      end
+
+      # @return [String] stripped text
+
+      def text
+        message['text_body']
+      end
+
+      # @return [String] an email address specified in `From` field
+
+      def mail_from
+        message['from_email']
+      end
+
+      # @return [String] recipient emails separated with `, `
+
+      def recipients
+        message['to_email'].split ', '
+      end
+
+      # @return [String] when email was received
+
+      def received_time
+        Time.parse(message['created_at']).to_s
+      end
+
+      # @return [String] a real sender email address
+
+      def sender_email
+        message['from_email']
+      end
+
+      # @return [Array] attachments
+
+      def mime_part
+        retrieve_attachments(message)
+      end
+
+      # @raise [NoAttachmentsError] if no attachments present
+      # @return [Array] attachments
+
+      def mime_part!
+        files = mime_part
+        return files if files.present?
+
+        raise Howitzer::NoAttachmentsError, 'No attachments were found.'
+      end
+
+      def self.find_retry_params(wait)
+        {
+          timeout: wait,
+          sleep: Howitzer.mail_sleep_time,
+          silent: true,
+          logger: Howitzer::Log,
+          on: Howitzer::EmailNotFoundError
+        }
+      end
+      private_class_method :find_retry_params
+
+      def self.retrieve_message(recipient, subject)
+        message = Howitzer::MailtrapApi::Client.new.find_message(recipient, subject)
+        raise Howitzer::EmailNotFoundError, 'Message not received yet, retry...' unless message
+
+        message
+      end
+      private_class_method :retrieve_message
+
+      private
+
+      def retrieve_attachments(message)
+        Howitzer::MailtrapApi::Client.new.find_attachments(message)
+      end
+    end
+  end
+end

data/lib/howitzer/mailgun_api/client.rb

@@ -9,9 +9,10 @@ module Howitzer
     # wrapper around RestClient so you don't have to worry about the HTTP aspect
     # of communicating with Mailgun API.
     class Client
-      USER_AGENT = 'mailgun-sdk-ruby'.freeze #:nodoc:
+      USER_AGENT = 'mailgun-sdk-ruby'.freeze # :nodoc:
       attr_reader :api_user, :api_key, :api_host, :api_version, :ssl
-      def initialize(api_user: 'api', api_key:, api_host: 'api.mailgun.net', api_version: 'v3', ssl: true)
+
+      def initialize(api_user: 'api', api_key: 'key', api_host: 'api.mailgun.net', api_version: 'v3', ssl: true)
         @api_user = api_user
         @api_key = api_key
         @api_host = api_host

data/lib/howitzer/mailgun_api/connector.rb

@@ -23,6 +23,7 @@ module Howitzer
       def client(api_key = Howitzer.mailgun_key)
         check_api_key(api_key)
         return @client if @api_key == api_key && @api_key
+
         @api_key = api_key
         @client = Client.new(api_key: @api_key)
       end

data/lib/howitzer/mailgun_api/response.rb

@@ -6,8 +6,7 @@ module Howitzer
     # by the Client request. The Response object supports deserialization of
     # the JSON result.
     class Response
-      attr_accessor :body
-      attr_accessor :code
+      attr_accessor :body, :code
 
       def initialize(response)
         @body = response.body

data/lib/howitzer/mailtrap_api/client.rb

@@ -0,0 +1,52 @@
+require 'json'
+require 'rest-client'
+
+module Howitzer
+  module MailtrapApi
+    # A Mailtrap::Client object is used to communicate with the Mailtrap API.
+    class Client
+      BASE_URL = "https://mailtrap.io/api/v1/inboxes/#{Howitzer.mailtrap_inbox_id}".freeze # :nodoc:
+
+      def initialize
+        @api_token = Howitzer.mailtrap_api_token
+      end
+
+      # Finds message according to given parameters
+      #
+      # @param recipient [String] this is recipient mail address for message filtering
+      # @param subject [String] this is subject of the message to filter particular message
+      # @return [Hash] json message parsed to ruby hash
+
+      def find_message(recipient, subject)
+        recipient = recipient.gsub('+', '%2B')
+        messages = filter_by_subject(messages(recipient), subject)
+        latest_message(messages)
+      end
+
+      # Finds attachments for message
+      #
+      # @param message [Hash] which attachments should be extracted
+      # @return [Array] returns array of attachments
+
+      def find_attachments(message)
+        JSON.parse(RestClient.get("#{BASE_URL}/messages/#{message['id']}/attachments", 'Api-Token' => @api_token))
+      end
+
+      private
+
+      def messages(recipient)
+        JSON.parse(RestClient.get("#{BASE_URL}/messages?search=#{recipient}", 'Api-Token' => @api_token))
+      end
+
+      def latest_message(messages)
+        messages[0]
+      end
+
+      def filter_by_subject(messages, subject)
+        result_messages = []
+        messages.each { |msg| result_messages << msg if msg['subject'] == subject }
+        result_messages
+      end
+    end
+  end
+end

data/lib/howitzer/mailtrap_api.rb

@@ -0,0 +1,7 @@
+module Howitzer
+  # This module holds simple implementation of mailtrap api client
+  module MailtrapApi
+  end
+end
+
+require 'howitzer/mailtrap_api/client'

data/lib/howitzer/meta/actions.rb

@@ -0,0 +1,35 @@
+module Howitzer
+  module Meta
+    # Module with utility actions for elements
+    module Actions
+      # Highlights element with red border on the page
+      # @param args [Array] arguments for elements described with lambda locators
+      # @param options [Hash] original Capybara options. For details, see `Capybara::Node::Finders#all`
+      def highlight(*args, **options)
+        if xpath(*args, **options).blank?
+          Howitzer::Log.debug("Element #{name} not found on the page")
+          return
+        end
+        element = escape(xpath(*args, **options))
+        context.execute_script(
+          "document.evaluate('#{element}', document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null)." \
+          'singleNodeValue.style.border = "thick solid red"'
+        )
+      end
+
+      # Returns xpath for the element
+      # @param args [Array] arguments for elements described with lambda locators
+      # @param options [Hash] original Capybara options. For details, see `Capybara::Node::Finders#all`
+      # @return [String, nil]
+      def xpath(*args, **options)
+        capybara_element(*args, **options).try(:path)
+      end
+
+      private
+
+      def escape(xpath)
+        xpath.gsub(/(['"])/, '\\\\\\1')
+      end
+    end
+  end
+end

data/lib/howitzer/meta/element.rb

@@ -0,0 +1,40 @@
+module Howitzer
+  module Meta
+    # This class represents element entity within howitzer meta information interface
+    class Element
+      attr_reader :name, :context
+
+      include Howitzer::Meta::Actions
+      # Creates new meta element with meta information and utility actions
+      # @param name [String] name of the element
+      # @param context [Howitzer::Web::Page] page element belongs to
+      def initialize(name, context)
+        @name = name
+        @context = context
+      end
+
+      # Finds all instances of element on the page and returns them as array of capybara elements
+      # @param args [Array] arguments for elements described with lambda locators
+      # @param options [Hash] original Capybara options. For details, see `Capybara::Node::Finders#all`
+      # @return [Array]
+      def capybara_elements(*args, **options)
+        if options.present?
+          context.send("#{name}_elements", *args, **options)
+        else
+          context.send("#{name}_elements", *args)
+        end
+      end
+
+      # Finds element on the page and returns as a capybara element
+      # @param args [Array] arguments for elements described with lambda locators
+      # @param options [Hash] original Capybara options. For details, see `Capybara::Node::Finders#all`
+      # @param wait [Integer] wait time for element search
+      # @return [Capybara::Node::Element, nil]
+      def capybara_element(*args, wait: 0, **options)
+        context.send("#{name}_element", *args, **options.merge(match: :first, wait: wait))
+      rescue Capybara::ElementNotFound
+        nil
+      end
+    end
+  end
+end

data/lib/howitzer/meta/entry.rb

@@ -0,0 +1,62 @@
+module Howitzer
+  module Meta
+    # This class provides access to meta information entities
+    class Entry
+      attr_reader :context
+
+      # Creates new meta entry instance for the page which provides access to elements, iframes and sections
+      # @param context [Howitzer::Web::Page] page for which entry is created
+      def initialize(context)
+        @context = context
+      end
+
+      # Returns array of elements
+      # @return [Array]
+      def elements
+        @elements ||= context
+                      .private_methods
+                      .grep(/\A(?!wait_)\w+_element\z/)
+                      .map { |el| Meta::Element.new(el.to_s.gsub('_element', ''), context) }
+      end
+
+      # Finds element by name
+      # @param name [String, Symbol] element name
+      # @return [Meta::Element]
+      def element(name)
+        elements.find { |el| el.name == name.to_s }
+      end
+
+      # Returns array of sections
+      # @return [Array]
+      def sections
+        @sections ||= context
+                      .public_methods
+                      .grep(/\A(?!wait_)\w+_section$\z/)
+                      .map { |el| Meta::Section.new(el.to_s.gsub('_section', ''), context) }
+      end
+
+      # Finds section by name
+      # @param name [String, Symbol] section name
+      # @return [Meta::Section]
+      def section(name)
+        sections.find { |el| el.name == name.to_s }
+      end
+
+      # Returns array of iframes
+      # @return [Array]
+      def iframes
+        @iframes ||= context
+                     .public_methods
+                     .grep(/\A(?!wait_)\w+_iframe$\z/)
+                     .map { |el| Meta::Iframe.new(el.to_s.gsub('_iframe', ''), context) }
+      end
+
+      # Finds iframe by name
+      # @param name [String, Symbol] iframe name
+      # @return [Meta::Iframe]
+      def iframe(name)
+        iframes.find { |el| el.name == name.to_s }
+      end
+    end
+  end
+end

data/lib/howitzer/meta/iframe.rb

@@ -0,0 +1,41 @@
+module Howitzer
+  module Meta
+    # This class represents iframe entity within howitzer meta information interface
+    class Iframe
+      attr_reader :name, :context
+
+      include Howitzer::Meta::Actions
+
+      # Creates new meta iframe element with meta information and utility actions
+      # @param name [String] name of the iframe
+      # @param context [Howitzer::Web::Page] page which has this iframe
+      def initialize(name, context)
+        @name = name
+        @context = context
+      end
+
+      # Finds all instances of iframe on the page and returns them as array of capybara elements
+      # @return [Array]
+      def capybara_elements
+        context.capybara_context.all("iframe[src='#{site_value}']")
+      end
+
+      # Finds iframe on the page and returns as a capybara element
+      # @param wait [Integer] wait time for element search
+      # @return [Capybara::Node::Element, nil]
+      def capybara_element(wait: 0)
+        context.capybara_context.find("iframe[src='#{site_value}']", match: :first, wait: wait)
+      rescue Capybara::ElementNotFound
+        nil
+      end
+
+      # Returns url value for iframe
+      # @return [String]
+      def site_value
+        return @site_value if @site_value.present?
+
+        context.send("#{name}_iframe") { |frame| @site_value = frame.class.send(:site_value) }
+      end
+    end
+  end
+end

data/lib/howitzer/meta/section.rb

@@ -0,0 +1,30 @@
+module Howitzer
+  module Meta
+    # This class represents section entity within howitzer meta information interface
+    class Section
+      attr_reader :name, :context
+
+      include Howitzer::Meta::Actions
+      # Creates meta section element with meta information and utility actions
+      # @param name [String] name of the section
+      # @param context [Howitzer::Web::Page] page which has this section
+      def initialize(name, context)
+        @name = name
+        @context = context
+      end
+
+      # Finds all instances of section on the page and returns them as array of capybara elements
+      # @return [Array]
+      def capybara_elements
+        context.send("#{name}_sections").map(&:capybara_context)
+      end
+
+      # Finds section on the page and returns as a capybara element
+      # @return [Capybara::Node::Element, nil]
+      def capybara_element
+        section = context.send("#{name}_sections").first
+        section.try(:capybara_context)
+      end
+    end
+  end
+end

data/lib/howitzer/meta.rb

@@ -0,0 +1,11 @@
+module Howitzer
+  # This module holds meta-information about elements on the page
+  module Meta
+  end
+end
+
+require 'howitzer/meta/actions'
+require 'howitzer/meta/element'
+require 'howitzer/meta/section'
+require 'howitzer/meta/iframe'
+require 'howitzer/meta/entry'

data/lib/howitzer/utils/string_extensions.rb

@@ -7,8 +7,12 @@ module Howitzer
       #   'home'.open #=> HomePage.open
       # @see Howitzer::Web::Page.open
 
-      def open(*args)
-        as_page_class.open(*args)
+      def open(*args, **options)
+        if options.present?
+          as_page_class.open(*args, **options)
+        else
+          as_page_class.open(*args)
+        end
       end
 
       # Returns an instantiated page by name

data/lib/howitzer/version.rb

@@ -1,4 +1,4 @@
 # This module holds howitzer version
 module Howitzer
-  VERSION = '2.0.3'.freeze #:nodoc:
+  VERSION = '2.3.0'.freeze # :nodoc:
 end

data/lib/howitzer/web/base_section.rb

@@ -15,7 +15,7 @@ module Howitzer
       attr_reader :parent
 
       class << self
-        attr_reader :default_finder_args
+        attr_reader :default_finder_args, :default_finder_options
       end
 
       def initialize(parent, context)

data/lib/howitzer/web/capybara_context_holder.rb

@@ -12,6 +12,7 @@ module Howitzer
 
       def capybara_scopes
         return super if defined?(super)
+
         raise NotImplementedError, "Please define 'capybara_scopes' method for class holder"
       end
     end

data/lib/howitzer/web/capybara_methods_proxy.rb

@@ -3,19 +3,21 @@ require 'active_support'
 require 'active_support/core_ext'
 
 # Remove this monkey patch after fixing the bugs in selenium-webdriver / capybara
-#:nocov:
+# :nocov:
 class Capybara::Selenium::Driver # rubocop:disable Style/ClassAndModuleChildren
   #
   # https://github.com/teamcapybara/capybara/issues/1845
   def title
     return browser.title unless within_frame?
+
     find_xpath('/html/head/title').map { |n| n[:text] }.first.to_s
   end
 
-  # Known issue, works differently for phantomjs and real browsers
+  # Known issue, works differently for real browsers
   # https://github.com/seleniumhq/selenium/issues/1727
   def current_url
     return browser.current_url unless within_frame?
+
     execute_script('return document.location.href')
   end
 
@@ -25,13 +27,13 @@ class Capybara::Selenium::Driver # rubocop:disable Style/ClassAndModuleChildren
     !(@frame_handles.blank? || @frame_handles[browser.window_handle].blank?)
   end
 end
-#:nocov:
+# :nocov:
 
 module Howitzer
   module Web
     # This module proxies required original capybara methods to recipient
     module CapybaraMethodsProxy
-      PROXIED_CAPYBARA_METHODS = Capybara::Session::SESSION_METHODS + #:nodoc:
+      PROXIED_CAPYBARA_METHODS = Capybara::Session::SESSION_METHODS + # :nodoc:
                                  Capybara::Session::MODAL_METHODS +
                                  %i[driver text]
 
@@ -39,7 +41,13 @@ module Howitzer
       # Instead of including Capybara::DSL module, we proxy most interesting Capybara methods and
       # prevent using extra methods which can potentially broke main principles and framework concept
       PROXIED_CAPYBARA_METHODS.each do |method|
-        define_method(method) { |*args, &block| Capybara.current_session.send(method, *args, &block) }
+        define_method(method) do |*args, **options, &block|
+          if options.present?
+            Capybara.current_session.send(method, *args, **options, &block)
+          else
+            Capybara.current_session.send(method, *args, &block)
+          end
+        end
       end
 
       # Accepts or declines JS alert box by given flag
@@ -57,7 +65,8 @@ module Howitzer
       private
 
       def capybara_scopes
-        @_scopes ||= [Capybara.current_session]
+        @capybara_scopes ||= Hash.new { |hash, key| hash[key] = [Capybara.current_session] }
+        @capybara_scopes[Howitzer.session_name]
       end
     end
   end