howitzer 0.0.1

data/lib/howitzer/utils/capybara_settings.rb

@@ -0,0 +1,110 @@
+require 'howitzer/utils/logger'
+module CapybaraSettings
+  extend self
+
+  def self.base_ff_profile_settings
+    profile = Selenium::WebDriver::Firefox::Profile.new
+    profile["network.http.phishy-userpass-length"] = 255
+    profile["browser.safebrowsing.malware.enabled"] = false
+    profile["network.automatic-ntlm-auth.allow-non-fqdn"] = true
+    profile["network.ntlm.send-lm-response"] = true
+    profile["network.automatic-ntlm-auth.trusted-uris"] = settings.app_main_host
+    profile
+  end
+
+  Capybara.run_server = false
+  Capybara.app_host = ''
+  Capybara.default_wait_time = settings.timeout_small
+  Capybara.ignore_hidden_elements = true
+  case settings.driver.to_sym
+    when :selenium
+      Capybara.register_driver :selenium do |app|
+        params = {browser: settings.sel_browser.to_sym}
+        params[:profile] = base_ff_profile_settings if ff_browser?
+        Capybara::Selenium::Driver.new app, params
+      end
+    when :selenium_dev
+      Capybara.register_driver :selenium_dev do |app|
+        profile = base_ff_profile_settings
+        fb_name = "firebug-#{settings.sel_firebug_version}-fx.xpi"
+        fp_name = "firepath-#{settings.sel_firepath_version}.xpi"
+        [fb_name, fp_name].each do |name|
+          profile.add_extension(File.expand_path(name, File.join('shared', 'vendor', 'firebug')))
+        end
+        profile['extensions.firebug.currentVersion']    = settings.sel_firebug_version # avoid 'first run' tab
+        profile["extensions.firebug.previousPlacement"] = 1
+        profile["extensions.firebug.onByDefault"]       = true
+        profile["extensions.firebug.defaultPanelName"]  = "firepath"
+        profile["extensions.firebug.script.enableSites"] = true
+        profile["extensions.firebug.net.enableSites"] = true
+        profile["extensions.firebug.console.enableSites"] = true
+
+        Capybara::Selenium::Driver.new app, browser: :firefox, profile: profile
+      end
+    when :webkit
+      require 'capybara-webkit'
+    when :poltergeist
+      require 'capybara/poltergeist'
+    when :sauce
+      caps_opts = {
+          platform: settings.sl_platform,
+          browser_name: settings.sl_browser_name,
+          name: 'Capybara test name should be overwritten',
+          "max-duration" => settings.sl_max_duration,
+          'idle-timeout' => settings.sl_idle_timeout,
+          'selenium-version' => settings.sl_selenium_version,
+          'record-screenshots' => settings.sl_record_screenshot,
+          'video-upload-on-pass' => settings.sl_video_upload_on_pass
+      }
+
+      unless (settings.sl_browser_version.to_s || "").empty?
+        caps_opts['browser-version'] = settings.sl_browser_version.to_s
+      end
+
+      options = {
+          url: settings.sl_url,
+          desired_capabilities: Selenium::WebDriver::Remote::Capabilities.new(caps_opts),
+          http_client: Selenium::WebDriver::Remote::Http::Default.new.tap{|c| c.timeout = settings.timeout_medium},
+          browser: :remote
+      }
+
+      Capybara.register_driver :sauce do |app|
+        Capybara::Selenium::Driver.new(app, options)
+      end
+
+    else
+      log.error "Unknown '#{settings.driver}' driver. Check your settings, it should be one of [selenium, selenium_dev, webkit, sauce]"
+  end
+
+  Capybara.default_driver = settings.driver.to_sym
+  Capybara.javascript_driver = settings.driver.to_sym
+
+  def sauce_resource_path(name)
+    host = "https://#{settings.sl_user}:#{settings.sl_api_key}@saucelabs.com"
+    path = "/rest/#{settings.sl_user}/jobs/#{session_id}/results/#{name}"
+    "#{host}#{path}"
+  end
+
+  def update_sauce_job_status(json_data = {})
+    host = "http://#{settings.sl_user}:#{settings.sl_api_key}@saucelabs.com"
+    path = "/rest/v1/#{settings.sl_user}/jobs/#{session_id}"
+    url = "#{host}#{path}"
+    RestClient.put url, json_data.to_json, content_type: :json, accept: :json
+  end
+
+  def suite_name
+    res = if ENV['RAKE_TASK']
+      res = ENV['RAKE_TASK'].sub(/(?:r?spec|cucumber):?(.*)/, '\1').upcase
+      res.empty? ? 'ALL' : res
+    else
+      'CUSTOM'
+    end
+    "#{res} #{settings.sl_browser_name.upcase}"
+  end
+
+  def session_id
+    Capybara.current_session.driver.browser.instance_variable_get(:@bridge).session_id
+  end
+
+end
+

data/lib/howitzer/utils/data_generator/data_storage.rb

@@ -0,0 +1,41 @@
+module DataGenerator
+
+  module DataStorage
+    @data ||= {}
+
+    class << self
+      def store(ns, key, value)
+        check_ns(ns)
+        @data[ns][key] = value
+      end
+
+      def extract(ns, key=nil)
+        check_ns(ns)
+        key ? @data[ns][key] : @data[ns]
+      end
+
+      def clear_ns(ns)
+        init_ns(ns)
+      end
+
+      private
+
+      def check_ns(ns)
+        if ns
+          init_ns(ns) if ns_absent?(ns)
+        else
+          raise 'Data storage namespace can not be empty'
+        end
+      end
+
+      def ns_absent?(ns)
+        !@data.key?(ns)
+      end
+
+      def init_ns(ns)
+        @data[ns] = {}
+      end
+
+    end
+  end
+end

data/lib/howitzer/utils/data_generator/gen.rb

@@ -0,0 +1,89 @@
+module DataGenerator
+  module Gen
+    # examples:
+    # member = Gen::user                          #user.email: 'u<XXXX>@<settings.mail_pop3_domain>'
+    # member = Gen::user('user@test.com')         #user.email: 'member@test.com'
+    # member = Gen::user(settings.def_test_user)           #user.email: settings.def_test_user
+
+    class << self
+      def user(params={})
+        prefix = serial
+        default = {
+            email: gen_user_email(prefix),
+            login: nil,
+            first_name: gen_first_name(prefix),
+            last_name: gen_last_name(prefix),
+            password: settings.def_test_pass
+        }
+        User.new(default.merge(params))
+      end
+
+      def given_user_by_number(num)
+        data = DataStorage.extract('user', num.to_i)
+        unless data
+          data = Gen::user
+          DataStorage.store('user', num.to_i, data)
+        end
+        data
+      end
+
+      def serial
+        a = [('a'..'z').to_a, (0..9).to_a].flatten.shuffle
+        "#{Time.now.utc.strftime("%j%H%M%S")}#{a[0..4].join}"
+      end
+
+      def delete_all_mailboxes
+        DataStorage.extract('user').each_value do |user|
+          user.delete_mailbox
+        end
+      end
+
+      private
+
+      def gen_user_email(serial=nil)
+        "#{gen_user_name(serial)}@#{settings.mail_pop3_domain}"
+      end
+
+      def gen_user_name(serial=nil)
+        gen_entity('u', serial)
+      end
+
+      def gen_first_name(serial=nil)
+        gen_entity('FirstName', serial)
+      end
+
+      def gen_last_name(serial=nil)
+        gen_entity('LastName', serial)
+      end
+
+      def gen_entity(prefix, serial)
+        "#{prefix}#{serial.nil? ? self.serial : serial}"
+      end
+    end
+
+    class User < Object
+
+      attr_reader :login, :domain, :email, :password, :mailbox, :first_name, :last_name, :full_name
+
+      def initialize(params={})
+        @email = params.delete(:email)
+        @email_name, @domain = @email.to_s.split('@')
+        @login = params.delete(:login) || @email_name
+        @password = params.delete(:password)
+        @first_name = params.delete(:first_name)
+        @last_name = params.delete(:last_name)
+        @full_name = "#@first_name #@last_name"
+        @mailbox = params.delete(:mailbox)
+      end
+
+      def create_mailbox
+        @mailbox = MailClient.create_mailbox(@email_name) if settings.mail_pop3_domain == @domain
+        self
+      end
+
+      def delete_mailbox
+        MailClient.delete_mailbox(@mailbox) unless @mailbox.nil?
+      end
+    end
+  end
+end

data/lib/howitzer/utils/email/email.rb

@@ -0,0 +1,46 @@
+require 'rspec/matchers'
+require 'howitzer/utils/email/mail_client'
+
+class Email
+  include RSpec::Matchers
+  attr_reader :recipient_address
+
+  def initialize(message)
+    message.subject.should include(self.class::SUBJECT)
+    @recipient_address = ::Mail::Address.new(message.to.first)
+    @message = message
+  end
+
+  def self.find_by_recipient(recipient)
+    find(recipient, self::SUBJECT)
+  end
+
+  def self.find(recipient, subject)
+      messages = MailClient.by_email(recipient).find_mail do |mail|
+       /#{Regexp.escape(subject)}/ === mail.subject && mail.to == [recipient]
+    end
+
+    if messages.first.nil?
+      log.error "#{self} was not found (recipient: '#{recipient}')"
+      messages.first.should_not be_nil
+    end
+    new(messages.first)
+  end
+
+  def plain_text_body
+    get_mime_part(@message, 'text/plain').to_s
+  end
+
+  def get_mime_part(part, type)
+    return part.body if part["content-type"].to_s =~ %r!#{type}!
+    # Recurse the multi-parts
+    part.parts.each do |sub_part|
+      r = get_mime_part(sub_part, type)
+      return r if r
+    end
+    nil
+  end
+
+  protected :get_mime_part
+
+end

data/lib/howitzer/utils/email/mail_client.rb

@@ -0,0 +1,126 @@
+require 'net/pop'
+require 'timeout'
+require 'mail'
+require 'howitzer/utils/email/mailgun_helper'
+
+class MailClient
+
+  extend MailgunHelper
+  @clients = {}
+
+  def self.default
+    log.info "Connect to default mailbox"
+    options = self.merge_opts
+    @clients[options] = MailClient.send :new unless @clients.has_key?(options)
+    @clients[options]
+  end
+
+  def self.by_email(name)
+    log.info "Connect to '#{name}' mailbox"
+    options = self.merge_opts(:pop3 => {:user_name => name}, :smtp => {})
+    @clients[options] = MailClient.send :new, options unless @clients.has_key?(options)
+    @clients[options]
+  end
+
+  def find_mail(max_wait = settings.mail_pop3_timeout, keep_or_delete = :delete, &block)
+    messages = []
+    time_of_start = Time.now
+    exception = nil
+    while Time.now < time_of_start + max_wait
+      begin
+        exception = nil
+        start do |pop_obj|
+          pop_obj.mails.each do |mail|
+            begin
+              mail_message = Mail.new(mail.pop.to_s)
+              if block_given?
+                if block.call(mail_message)
+                  if keep_or_delete == :delete
+                    mail.delete
+                    log.info "Mail '#{mail_message.subject}' deleted from #{@options[:pop3][:user_name]}"
+                  end
+                  messages << mail_message
+                  @old_ids << mail.unique_id
+                  return messages
+                end
+              else
+                messages << mail_message
+              end
+            rescue Net::POPError => e
+              log.warn "Exception in POP find_mail: #{e.message}"
+              exception = e
+            end
+          end
+        end
+
+        sleep 5
+      rescue Errno::ETIMEDOUT, Errno::ECONNRESET, Net::POPAuthenticationError => e
+        log.warn "Exception in POP find_mail: #{e.message}. Will retry."
+        exception = e
+      end
+    end
+    log.error exception unless exception.nil?
+    messages
+  end
+
+  def send_mail(mail_from, mail_to, mail_subject, mail_body, mail_attachment=nil)
+    log.info "Send emails with next parameters:\n " +
+                 "mail_from : #{mail_from},\n mail_to : #{mail_to}\n " +
+                 "mail_subject : #{mail_subject},\n has_attachment? : #{!mail_attachment.nil?}"
+    outbound_mail = Mail.new do
+      from(mail_from)
+      subject(mail_subject)
+      body(mail_body)
+      add_file(mail_attachment) unless mail_attachment.nil?
+    end
+    outbound_mail[:to] = mail_to
+
+    retryable(:on => [Errno::ETIMEDOUT, Timeout::Error], :sleep => 10, :tries => 3, :trace => true, :logger => log) do
+      outbound_mail.deliver!
+    end
+  end
+
+  def empty_inbox
+    begin
+      start {|pop_obj| pop_obj.delete_all }
+      log.info "Email box (#{@options[:pop3][:user_name]}) was purged"
+    rescue Net::POPError => e
+      log.warn "Exception during deletion all messages from '#{@options[:pop3][:user_name]}':\n#{e.message}"
+    end
+  end
+
+  def start(&block)
+    retryable(:timeout => settings.mail_pop3_timeout, :sleep => 5, :trace => true, :logger => log) do
+      Net::POP3.start(@options[:pop3][:address], @options[:pop3][:port],
+                    @options[:pop3][:user_name], @options[:pop3][:password], &block)
+    end
+  end
+
+  private
+  def initialize(*arg)
+    @options = MailClient.merge_opts(*arg)
+    Net::POP3.enable_ssl(OpenSSL::SSL::VERIFY_NONE)
+    @old_ids = []
+    options = @options
+    ::Mail.defaults{delivery_method :smtp, options[:smtp]}
+    @time_of_start = Time.now
+  end
+
+  def self.merge_opts(opts={:smtp => {}, :pop3 => {}})
+    def_smtp_opts = {:address => settings.mail_smtp_server,
+                     :port => settings.mail_smtp_port,
+                     :domain => settings.mail_smtp_domain,
+                     :user_name => settings.mail_smtp_user_name,
+                     :password => settings.mail_smtp_user_pass,
+                     :authentication => 'plain',
+                     :enable_starttls_auto => true}
+
+    def_pop3_opts = {:address => settings.mail_pop3_server,
+                     :port => settings.mail_pop3_port,
+                     :user_name => settings.mail_pop3_user_name,
+                     :password => settings.mail_pop3_user_pass}
+    {:smtp => def_smtp_opts.merge(opts[:smtp]),
+     :pop3 => def_pop3_opts.merge(opts[:pop3])}
+  end
+
+end

data/lib/howitzer/utils/email/mailgun.rb

@@ -0,0 +1,175 @@
+#For details, please see https://github.com/mailgun/mailgun.rb or https://github.com/hardikshah/mailgun.rb
+#Modified from original adding rest-client 'remove'
+require 'active_resource'
+require 'rest-client'
+
+class Mailgun
+
+  # Initializes Mailgun API
+  # Must be called before any other method
+  #
+  # Parameters:
+  # api_key - Your API key
+  # api_url - API base URL
+  #
+  def self.init(api_key, api_url = "https://mailgun.net/api/")
+    MailgunResource.password = api_key
+    api_url = api_url.gsub(/\/$/, '') + "/"
+    MailgunResource.site = api_url
+  end
+
+  # This is a patch of private ActiveResource method.
+  # It takes HTTPResponse and raise AR-like error if response code is not 2xx
+  def self.handle_response(response)
+    case response.code.to_i
+      when 301,302
+        raise(Redirection.new(response))
+      when 200...400
+        response
+      when 400
+        raise(ActiveResource::BadRequest.new(response))
+      when 401
+        raise(ActiveResource::UnauthorizedAccess.new(response))
+      when 403
+        raise(ActiveResource::ForbiddenAccess.new(response))
+      when 404
+        raise(ActiveResource::ResourceNotFound.new(response))
+      when 405
+        raise(ActiveResource::MethodNotAllowed.new(response))
+      when 409
+        raise(ActiveResource::ResourceConflict.new(response))
+      when 410
+        raise(ActiveResource::ResourceGone.new(response))
+      when 422
+        raise(ActiveResource::ResourceInvalid.new(response))
+      when 401...500
+        raise(ActiveResource::ClientError.new(response))
+      when 500...600
+        raise(ActiveResource::ServerError.new(response))
+      else
+        raise(ConnectionError.new(response, "Unknown response code: #{response.code}"))
+    end
+  end
+
+  module RequestBuilder
+    def prepare_request(url_string)
+      uri = URI.parse(url_string)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true if uri.port == 443
+      return [http, (uri.path + '?' + uri.query)]
+    end
+  end
+end
+
+class MailgunMessage
+  extend Mailgun::RequestBuilder
+
+  MAILGUN_TAG = 'X-Mailgun-Tag'
+
+  # Sends a MIME-formatted message
+  #
+  # raw_mime =
+  # "Content-Type: text/plain;charset=utf-8\n" +
+  # "From: me@host\n" +
+  # "To: you@host\n" +
+  # "Subject: Hello!\n\n" +
+  # "Body"
+  # MailgunMessage::send_raw("me@host", "you@host", raw_mime)
+  #
+  def self.send_raw(sender, recipients, raw_body, servername='')
+    uri_str = "#{MailgunResource.site}messages.eml?api_key=#{MailgunResource.password}&servername=#{servername}"
+    http, url = prepare_request(uri_str)
+    data = "#{sender}\n#{recipients}\n\n#{raw_body}"
+    res = http.post(url, data, {"Content-type" => "text/plain" })
+    Mailgun::handle_response(res)
+  end
+
+  # Sends a plain-text message
+  #
+  # MailgunMessage::send_text("me@host.com",
+  # "you@host.com",
+  # "Subject",
+  # "Hi!\nThis is message body")
+  #
+  def self.send_text(sender, recipients, subject, text, servername='', options = nil)
+    uri_str = "#{MailgunResource.site}messages.txt?api_key=#{MailgunResource.password}&servername=#{servername}"
+    params = { :sender => sender, :recipients => recipients, :subject => subject, :body => text}
+    unless options.nil?
+      params['options'] = ActiveSupport::JSON.encode(options)
+    end
+    http, url = prepare_request(uri_str)
+    req = Net::HTTP::Post.new(url)
+    req.set_form_data(params)
+    res = http.request(req)
+    Mailgun::handle_response(res)
+  end
+end
+
+# Base class for Mailgun resource classes
+# It adds upsert() method on top of ActiveResource::Base
+#
+class MailgunResource < ActiveResource::Base
+  self.user = "api_key"
+  extend Mailgun::RequestBuilder
+
+  # Create new resource or update it if resource already exist.
+  # There are 2 differences between upsert() and save():
+  # - Upsert does not raise an exception if a resource already exist.
+  # - Upsert does not return the id of freshly inserted resource
+  #
+  # >> route = Route.new
+  # >> route.pattern = '*@mydomain.com'
+  # >> route.destination = 'http://mydomain.com/addcomment'
+  # >> route.upsert()
+  #
+  def upsert()
+    self.class.post('upsert', {}, self.to_xml())
+  end
+end
+
+# All mail arriving to emails addresses that have mailboxes associated
+# will be stored on the server and can be later accessed via IMAP or POP3
+# protocols.
+#
+# Mailbox has several properties:
+#
+# alex@gmail.com
+# ^ ^
+# | |
+# user domain
+#
+class Mailbox < MailgunResource
+  # Example of a CSV file:
+  #
+  # john@domain.com, password
+  # doe@domain.com, password2
+  #
+  def self.upsert_from_csv(mailboxes)
+    uri_str = "#{MailgunResource.site}mailboxes.txt?api_key=#{MailgunResource.password}"
+    http, url = prepare_request(uri_str)
+    res = http.post(url, mailboxes, {"Content-type" => "text/plain" })
+    Mailgun::handle_response(res)
+  end
+
+  def self.remove(mailbox)
+    res = RestClient.delete "https://api:#{MailgunResource.password}"\
+    "@api.mailgun.net/v2/#{mailbox.domain}/mailboxes/#{mailbox.user}"
+    Mailgun::handle_response(res)
+  end
+end
+
+
+# This class represents Mailgun route.
+# A route has 2 properties: pattern and destination
+#
+# Examples of patterns:
+# - '*' - match all
+# - exact match (foo@bar.com)
+# - domain pattern, i.e. a pattern like "@example.com" - it will match all emails going to example.com
+# - any regular expression
+#
+# Destination can be one of:
+# - an emails address to forward to
+# - a URL for HTTP POST
+class Route < MailgunResource
+end