howitzer 1.1.1 → 2.0.0

data/lib/howitzer/log.rb

@@ -0,0 +1,120 @@
+require 'log4r'
+require 'fileutils'
+require 'active_support/core_ext/module'
+
+module Howitzer
+  # This class represents logger
+  class Log
+    include Singleton
+    include Log4r
+
+    class << self
+      # Delegates all public instance methods to the class
+      delegate :debug, :info, :warn, :fatal, :error, :print_feature_name,
+               :settings_as_formatted_text, :print_scenario_name, to: :instance
+    end
+
+    # Outputs debug message if Howitzer.debug_mode == true
+    # @param msg [String] a message
+
+    def debug(msg)
+      @logger.debug(msg)
+    end
+
+    # Outputs info message
+    # @param msg [String] a message
+
+    def info(msg)
+      @logger.info(msg)
+    end
+
+    # Outputs warn message
+    # @param msg [String] a message
+
+    def warn(msg)
+      @logger.warn(msg)
+    end
+
+    # Outputs error message
+    # @param msg [String] a message
+
+    def error(msg)
+      @logger.error(msg)
+    end
+
+    # Outputs fatal message
+    # @param msg [String] a message
+
+    def fatal(msg)
+      @logger.fatal(msg)
+    end
+
+    # Outputs a feature name into the log with INFO severity
+    # @param text [String] a feature name
+
+    def print_feature_name(text)
+      log_without_formatting { info "*** Feature: #{text.upcase} ***" }
+    end
+
+    # Outputs formatted howitzer settings
+
+    def settings_as_formatted_text
+      log_without_formatting { info ::SexySettings::Base.instance.as_formatted_text }
+    end
+
+    # Outputs a scenario name into log with INFO severity
+    # @param text [String] a scenario name
+
+    def print_scenario_name(text)
+      log_without_formatting { info " => Scenario: #{text}" }
+    end
+
+    private
+
+    def initialize
+      @logger = Logger.new('ruby_log')
+      @logger.add(console_log)
+      @logger.add(error_log)
+      self.base_formatter = default_formatter
+      Logger['ruby_log'].level = Howitzer.debug_mode ? ALL : INFO
+      Logger['ruby_log'].trace = true
+    end
+
+    #:nocov:
+    def log_without_formatting
+      self.base_formatter = blank_formatter
+      yield
+      self.base_formatter = default_formatter
+    end
+    #:nocov:
+
+    def console_log
+      StdoutOutputter.new(:console).tap { |o| o.only_at(INFO, DEBUG, WARN) }
+    end
+
+    def error_log
+      StderrOutputter.new(:error, 'level' => ERROR)
+    end
+
+    #:nocov:
+    def blank_formatter
+      PatternFormatter.new(pattern: '%m')
+    end
+    #:nocov:
+
+    #:nocov:
+    def default_formatter
+      params = if Howitzer.hide_datetime_from_log
+                 { pattern: '[%l] %m' }
+               else
+                 { pattern: '%d [%l] :: %m', date_pattern: '%Y/%m/%d %H:%M:%S' }
+               end
+      PatternFormatter.new(params)
+    end
+    #:nocov:
+
+    def base_formatter=(formatter)
+      @logger.outputters.each { |outputter| outputter.formatter = formatter }
+    end
+  end
+end

data/lib/howitzer/mail_adapters.rb

@@ -0,0 +1,7 @@
+module Howitzer
+  # This module holds all mail adapters
+  module MailAdapters
+  end
+end
+
+require 'howitzer/mail_adapters/abstract'

data/lib/howitzer/mail_adapters/abstract.rb

@@ -0,0 +1,84 @@
+module Howitzer
+  module MailAdapters
+    # +Abstract+ is the superclass of all mail adapters.
+    #
+    # @abstract This class should not be used directly. Instead, create a
+    #  subclass that implements:
+    #  {.find}
+    #  {#plain_text_body}
+    #  {#html_body}
+    #  {#text}
+    #  {#mail_from}
+    #  {#recipients}
+    #  {#received_time}
+    #  {#sender_email}
+    #  {#mime_part}
+    class Abstract
+      attr_reader :message
+
+      # Finds an email in mailbox
+      # @param recipient [String] an email
+      # @param subject [String]
+
+      def self.find(_recipient, _subject)
+        raise NotImplementedError
+      end
+
+      # Creates a new instance of email
+
+      # @param message [Object] original message data
+
+      def initialize(message)
+        @message = message
+      end
+
+      # Returns a plain text body of the email message
+
+      def plain_text_body
+        raise NotImplementedError
+      end
+
+      # Returns a html body of the email message
+
+      def html_body
+        raise NotImplementedError
+      end
+
+      # Returns a mail text
+
+      def text
+        raise NotImplementedError
+      end
+
+      # Returns who has sent email data in format: User Name <user@email>
+
+      def mail_from
+        raise NotImplementedError
+      end
+
+      # Returns an array of recipients who has received current email
+
+      def recipients
+        raise NotImplementedError
+      end
+
+      # Returns email received time
+
+      def received_time
+        raise NotImplementedError
+      end
+
+      # Returns sender user email
+
+      def sender_email
+        raise NotImplementedError
+      end
+
+      # Allows to get email MIME attachment
+
+      def mime_part
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/howitzer/mail_adapters/mailgun.rb

@@ -0,0 +1,115 @@
+require 'howitzer/mailgun_api/connector'
+require 'howitzer/exceptions'
+require 'howitzer/mail_adapters/abstract'
+
+module Howitzer
+  module MailAdapters
+    # This class represents Mailgun mail adapter
+    class Mailgun < Abstract
+      # Finds an email in storage
+      # @note emails are stored for 3 days only!
+      # @param recipient [String] an email
+      # @param subject [String]
+      # @raise [EmailNotFoundError] if message blank
+
+      def self.find(recipient, subject)
+        message = {}
+        retryable(find_retry_params) { 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['body-plain']
+      end
+
+      # @return [String] html body of the email message
+
+      def html_body
+        message['stripped-html']
+      end
+
+      # @return [String] stripped text
+
+      def text
+        message['stripped-text']
+      end
+
+      # @return [String] an email address specified in `From` field
+
+      def mail_from
+        message['From']
+      end
+
+      # @return [String] recipient emails separated with `, `
+
+      def recipients
+        message['To'].split ', '
+      end
+
+      # @return [String] when email was received
+
+      def received_time
+        message['Received'][/\w+, \d+ \w+ \d+ \d+:\d+:\d+ -\d+ \(\w+\)$/]
+      end
+
+      # @return [String] a real sender email address
+
+      def sender_email
+        message['sender']
+      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 where found.'
+      end
+
+      def self.events
+        MailgunApi::Connector.instance.client.get(
+          "#{MailgunApi::Connector.instance.domain}/events", params: { event: 'stored' }
+        )
+      end
+      private_class_method :events
+
+      def self.event_by(recipient, subject)
+        events.to_h['items'].find do |hash|
+          hash['message']['recipients'].first == recipient && hash['message']['headers']['subject'] == subject
+        end
+      end
+      private_class_method :event_by
+
+      def self.find_retry_params
+        {
+          timeout: Howitzer.mailgun_idle_timeout,
+          sleep: Howitzer.mailgun_sleep_time,
+          silent: true,
+          logger: Howitzer::Log,
+          on: Howitzer::EmailNotFoundError
+        }
+      end
+      private_class_method :find_retry_params
+
+      def self.retrieve_message(recipient, subject)
+        event = event_by(recipient, subject)
+        raise Howitzer::EmailNotFoundError, 'Message not received yet, retry...' unless event
+
+        message_url = event['storage']['url']
+        MailgunApi::Connector.instance.client.get_url(message_url).to_h
+      end
+      private_class_method :retrieve_message
+    end
+  end
+end

data/lib/howitzer/mailgun_api.rb

@@ -0,0 +1,9 @@
+module Howitzer
+  # This module holds simple implementation of mailgun api client
+  module MailgunApi
+  end
+end
+
+require 'howitzer/mailgun_api/response'
+require 'howitzer/mailgun_api/client'
+require 'howitzer/mailgun_api/connector'

data/lib/howitzer/mailgun_api/client.rb

@@ -0,0 +1,79 @@
+require 'rest-client'
+require 'json'
+require 'howitzer/mailgun_api/response'
+require 'howitzer/exceptions'
+
+module Howitzer
+  module MailgunApi
+    # A Mailgun::Client object is used to communicate with the Mailgun API. It is a
+    # 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
+      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)
+        @api_user = api_user
+        @api_key = api_key
+        @api_host = api_host
+        @api_version = api_version
+        @ssl = ssl
+        @http_client = ::RestClient::Resource.new(endpoint, user: api_user, password: api_key, user_agent: USER_AGENT)
+      end
+
+      # Generic Mailgun GET Handler
+      #
+      # @param resource_path [String] this is the API resource you wish to interact
+      #   with. Be sure to include your domain, where it is necessary.
+      # @param params [Hash] this should be a standard Hash for query
+      #   containing required parameters for the requested resource.
+      # @raise [CommunicationError] if something went wrong
+      # @return [Mailgun::Response] a Mailgun::Response object.
+
+      def get(resource_path, params: nil, accept: '*/*')
+        http_params = { accept: accept }
+        http_params = http_params.merge(params: params) if params
+        response = http_client[resource_path].get(http_params)
+        Response.new(response)
+      rescue => e
+        raise Howitzer::CommunicationError, e.message
+      end
+
+      # Extracts data by url in custom way
+      # @note This method was introducted because of saving emails to different nodes.
+      #   As result we can not use {#get} method, because client holds general api url
+      #
+      # @param resource_url [String] a full url
+      # @param params [Hash] this should be a standard Hash for query
+      #   containing required parameters for the requested resource.
+      # @param accept [String] an accept pattern for headers
+      # @raise [CommunicationError] if something went wrong
+      # @return [Mailgun::Response] a Mailgun::Response object.
+
+      def get_url(resource_url, params: nil, accept: '*/*')
+        response = ::RestClient::Request.execute(
+          method: :get,
+          url: resource_url,
+          user: api_user,
+          password: api_key,
+          user_agent: USER_AGENT,
+          accept: accept,
+          params: params
+        )
+        Response.new(response)
+      rescue => e
+        raise Howitzer::CommunicationError, e.message
+      end
+
+      private
+
+      attr_reader :http_client
+
+      def endpoint
+        scheme = "http#{'s' if ssl}"
+        res = "#{scheme}://#{api_host}"
+        res << "/#{api_version}" if api_version
+        res
+      end
+    end
+  end
+end

data/lib/howitzer/mailgun_api/connector.rb

@@ -0,0 +1,37 @@
+require 'singleton'
+require 'howitzer/mailgun_api/client'
+require 'howitzer/exceptions'
+
+module Howitzer
+  module MailgunApi
+    # This class represent connector to Mailgun service
+    class Connector
+      include Singleton
+
+      attr_reader :api_key
+      attr_accessor :domain
+
+      # Assigns default value for a domain
+
+      def initialize
+        self.domain = Howitzer.mailgun_domain
+      end
+
+      # @return [Client] a mailgun client
+      # @raise [InvalidApiKeyError] if api_key is blank
+
+      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
+
+      private
+
+      def check_api_key(api_key)
+        raise Howitzer::InvalidApiKeyError, 'Api key can not be blank' if api_key.blank?
+      end
+    end
+  end
+end