howitzer 0.0.3 → 1.0.1

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

@@ -1,19 +1,53 @@
 module DataGenerator
 
+  ##
+  #
+  # Data can be stored in memory using DataStorage
+  #
+
   module DataStorage
     @data ||= {}
 
     class << self
+
+      ##
+      #
+      # Saves data into memory. Marking by namespace and key
+      #
+      # *Parameters:*
+      # * +ns+ - Namespace
+      # * +key+ - Key that should be uniq in namespace
+      # * +value+ - Data value
+      #
+
+
       def store(ns, key, value)
         check_ns(ns)
         @data[ns][key] = value
       end
 
+      ##
+      #
+      # Gets data from memory. Can get all namespace or single data value in namespace using key
+      #
+      # *Parameters:*
+      # * +ns+ - Namespace
+      # * +key+ - Key that isn't necessary required (default to: nil)
+      #
+
       def extract(ns, key=nil)
         check_ns(ns)
         key ? @data[ns][key] : @data[ns]
       end
 
+      ##
+      #
+      # Deletes all records from namespace
+      #
+      # *Parameters:*
+      # * +ns+ - Namespace
+      #
+
       def clear_ns(ns)
         init_ns(ns)
       end
@@ -38,4 +72,4 @@ module DataGenerator
 
     end
   end
-end
+end

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

@@ -1,11 +1,28 @@
 module DataGenerator
   module Gen
-    # examples:
+
+    ##
+    #
+    # This module generates uniq User object with uniq generated data.
+    # 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
+    # member = Gen::user(settings.def_test_user)  #user.email: settings.def_test_user
 
     class << self
+
+      ##
+      #
+      # Generates new User object with generated data.
+      #
+      # *Parameters:*
+      # * +params+ - Custom parameters
+      #
+      # *Returns:*
+      # * +user+ - New generated User object
+      #
+
+
       def user(params={})
         prefix = serial
         default = {
@@ -18,6 +35,17 @@ module DataGenerator
         User.new(default.merge(params))
       end
 
+      ##
+      #
+      # Gets User object by it's number
+      #
+      # *Parameters:*
+      # * +num+ - User number
+      #
+      # *Returns:*
+      # * +user+ - User object
+      #
+
       def given_user_by_number(num)
         data = DataStorage.extract('user', num.to_i)
         unless data
@@ -27,11 +55,25 @@ module DataGenerator
         data
       end
 
+      ##
+      #
+      # Generates uniq string
+      # @return [String]                          Generated string
+      #
+      # *Returns:*
+      # * +string+ - Generated string
+      #
+
       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
 
+      ##
+      #
+      # Deletes mailboxes for all users that were generated before
+      #
+
       def delete_all_mailboxes
         DataStorage.extract('user').each_value do |user|
           user.delete_mailbox
@@ -86,4 +128,4 @@ module DataGenerator
       end
     end
   end
-end
+end

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

@@ -5,32 +5,71 @@ class Email
   include RSpec::Matchers
   attr_reader :recipient_address
 
+  ##
+  #
+  # Creates new email with message
+  #
+  # *Parameters:*
+  # * +message+ - email message
+  #
+
   def initialize(message)
-    message.subject.should include(self.class::SUBJECT)
+    expect(message.subject).to include(self.class::SUBJECT)
     @recipient_address = ::Mail::Address.new(message.to.first)
     @message = message
   end
 
+  ##
+  #
+  # Search mail by recepient
+  #
+  # *Parameters:*
+  # * +recepient+ - recepient's email address
+  #
+
   def self.find_by_recipient(recipient)
     find(recipient, self::SUBJECT)
   end
 
+  ##
+  #
+  # Search mail by recepient and subject.
+  #
+  # *Parameters:*
+  # * +recepient+ - recepient's email address
+  # * +subject+ - email subject
+  #
+
   def self.find(recipient, subject)
-      messages = MailClient.by_email(recipient).find_mail do |mail|
-       /#{Regexp.escape(subject)}/ === mail.subject && mail.to == [recipient]
+    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
+      return   # TODO check log.error raises error
     end
     new(messages.first)
   end
 
+  ##
+  #
+  # Returns plain text body of email message
+  #
+
   def plain_text_body
     get_mime_part(@message, 'text/plain').to_s
   end
 
+  ##
+  #
+  # Allows to get email MIME attachment
+  #
+  # *Parameters:*
+  # * +part+ - recepient's email address
+  # * +type+ - MIME message part
+  #
+
   def get_mime_part(part, type)
     return part.body if part["content-type"].to_s =~ %r!#{type}!
     # Recurse the multi-parts
@@ -43,4 +82,4 @@ class Email
 
   protected :get_mime_part
 
-end
+end

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

@@ -10,18 +10,41 @@ class MailClient
 
   def self.default
     log.info "Connect to default mailbox"
-    options = self.merge_opts
-    @clients[options] = MailClient.send :new unless @clients.has_key?(options)
+    options = merge_opts
+    @clients[options] = 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)
+    options = self.merge_opts(pop3: { user_name: name }, smtp: {})
+    @clients[options] = new(options) unless @clients.has_key?(options)
     @clients[options]
   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
+
   def find_mail(max_wait = settings.mail_pop3_timeout, keep_or_delete = :delete, &block)
     messages = []
     time_of_start = Time.now
@@ -98,7 +121,7 @@ class MailClient
 
   private
   def initialize(*arg)
-    @options = MailClient.merge_opts(*arg)
+    @options = self.class.merge_opts(*arg)
     Net::POP3.enable_ssl(OpenSSL::SSL::VERIFY_NONE)
     @old_ids = []
     options = @options
@@ -106,21 +129,4 @@ class MailClient
     @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_helper.rb

@@ -1,5 +1,16 @@
 module MailgunHelper
 
+  ##
+  #
+  # Creates new mailbox for given user_name
+  #
+  # *Parameters:*
+  # * +user_name+ - user name
+  # * +domain+ - domain (default to: settings.mail_pop3_domain )
+  # * +password+ - password (default to: settings.mail_pop3_user_pass )
+  #
+
+
   def create_mailbox(user_name,
                      domain=settings.mail_pop3_domain,
                      password=settings.mail_pop3_user_pass)
@@ -9,6 +20,14 @@ module MailgunHelper
     mbox
   end
 
+  ##
+  #
+  # Deletes given mailbox
+  #
+  # *Parameters:*
+  # * +mailbox+ - mailbox to delete
+  #
+
   def delete_mailbox(mailbox)
     log.info "Delete '#{mailbox.user}@#{mailbox.domain}' mailbox"
     begin
@@ -18,11 +37,18 @@ module MailgunHelper
     end
   end
 
+  ##
+  #
+  # Deletes all mailboxes except those in exceptions
+  #
+  # *Parameters:*
+  # * +exceptions+ - list of email addresses
+  #
+
   def delete_all_mailboxes(*exceptions)
-    puts exceptions.inspect
-    exceptions += %w"postmaster@#{settings.mail_smtp_domain}" #system and default mailbox
+    exceptions += ["postmaster@#{settings.mail_smtp_domain}"] #system and default mailbox
     exceptions = exceptions.uniq
-    log.info "Delete all mailboxes #{"except: " + exceptions.inspect unless exceptions.empty?}"
+    log.info "Delete all mailboxes except: #{exceptions.map(&:inspect).join(', ')}"
     i = 0
     Mailbox.find(:all).each do |m|
       next if exceptions.include?("#{m.user}@#{m.domain}")
@@ -32,4 +58,4 @@ module MailgunHelper
 
     log.info "Were deleted '#{i}' mailboxes"
   end
-end
+end

data/lib/howitzer/utils/locator_store.rb

@@ -18,52 +18,156 @@
 
 
 module LocatorStore
+  BadLocatorParamsError = Class.new(StandardError)
+  LocatorNotDefinedError = Class.new(StandardError)
+
   def self.included(base)
     base.extend(ClassMethods)
   end
 
   module ClassMethods
+    LOCATOR_TYPES = [:base, :link, :field, :button]
     class BadLocatorParamsError < StandardError; end
     class LocatorNotSpecifiedError < StandardError; end
 
+    ##
+    #
+    # Adds css or xpath locator into LocatorStore.
+    # Also locator can be set by lambda expression. For example: lambda{|name|{xpath: ".//a[@id='#{name}']"}}
+    #
+    # *Parameters:*
+    # * +name+ - Locator name
+    # * +params+ - String for css locator or hash with :xpath key and string value for xpath locator
+    #
+
     def add_locator(name, params)
       add_locator_by_type(:base, name, params)
     end
 
+    ##
+    #
+    # Adds locator for link into LocatorStore. Link can be found by: id, text
+    # Capybara methods that can work with this locator type are: click_link, find_link
+    #
+    # *Parameters:*
+    # * +name+ - Locator name
+    # * +params+ - ID or text of link
+    #
+
     def add_link_locator(name, params)
       add_locator_by_type(:link, name, params)
     end
 
+    ##
+    #
+    # Adds locator for field into LocatorStore. Field can be found by: name, id, text
+    # Capybara methods that can work with this locator type are: find_field, fill_in
+    #
+    # *Parameters:*
+    # * +name+ - Locator name
+    # * +params+ - Name, ID or text of field
+    #
+
     def add_field_locator(name, params)
       add_locator_by_type(:field, name, params)
     end
 
+    ##
+    #
+    # Add locator for button into LocatorStore. Button can be found by: id, name, value
+    # Capybara methods that can work with this locator type are: click_button, find_button
+    #
+    # *Parameters:*
+    # * +name+ - Locator name
+    # * +params+ - Name, ID or value
+    #
+
     def add_button_locator(name, params)
       add_locator_by_type(:button, name, params)
     end
 
+    ##
+    #
+    # Takes css or xpath locator from LocatorStore by name
+    #
+    # *Parameters:*
+    # * +name+ - Locator name
+    #
+
     def locator(name)
       locator_by_type(:base, name)
     end
 
+    ##
+    #
+    # Take link locator from LocatorStore by name
+    #
+    # *Parameters:*
+    # * +name+ - Locator name
+    #
+
     def link_locator(name)
       locator_by_type(:link, name)
     end
 
+    ##
+    #
+    # Take field locator from LocatorStore by name
+    #
+    # *Parameters:*
+    # * +name+ - Locator name
+    #
+
     def field_locator(name)
       locator_by_type(:field, name)
     end
 
+    ##
+    #
+    # Take button locator from LocatorStore be name
+    #
+    # *Parameters:*
+    # * +name+ - Locator name
+    #
+
     def button_locator(name)
       locator_by_type(:button, name)
     end
 
+    ##
+    #
+    # Get locator set by lambda.
+    # For example: find(apply(locator(:locator_name), 'register')).click
+    #
+    # *Parameters:*
+    # * +locator+ - Locator set with lambda expression
+    # * +values+ - Arguments that should be matched lambda expression params
+    #
+
     def apply(locator, *values)
       locator.call(*values).to_a.flatten
     end
 
+    def find_element(name)
+      type, locator = find_locator(name)
+      if type == :base
+        send :find, locator
+      else
+        send "find_#{type}", locator
+      end
+    end
+
     protected
 
+    def find_locator(name)
+      name = name.to_s.to_sym
+      LOCATOR_TYPES.each do|type|
+        return [type, locator_by_type(type, name)] if (@locators || {}).fetch(self.name, {}).fetch(type, {})[name]
+      end
+      raise(LocatorNotDefinedError, name)
+    end
+
+    # looks up locator in current and all super classes
     def parent_locator(type, name)
       if !@locators.nil? && @locators.key?(self.name) && @locators[self.name].key?(type) && @locators[self.name][type].key?(name)
         @locators[self.name][type][name]
@@ -76,7 +180,7 @@ module LocatorStore
 
     def locator_by_type(type, name)
       locator = parent_locator(type, name)
-      raise(LocatorNotSpecifiedError, name) if locator.nil?
+      raise(LocatorNotDefinedError, name) if locator.nil?
       locator
     end
 
@@ -96,23 +200,11 @@ module LocatorStore
     end
   end
 
-  def locator(name)
-    self.class.locator(name)
-  end
-
-  def link_locator(name)
-    self.class.link_locator(name)
-  end
-
-  def field_locator(name)
-    self.class.field_locator(name)
-  end
-
-  def button_locator(name)
-    self.class.button_locator(name)
+  #delegate class methods to instance
+  ClassMethods.public_instance_methods.each do |name|
+    define_method(name) do |*args|
+      self.class.send(name, *args)
+    end
   end
 
-  def apply(locator, *values)
-    self.class.apply(locator, *values)
-  end
-end
+end