mini_autobot 0.0.1

data/lib/mini_autobot/utils/castable.rb

@@ -0,0 +1,103 @@
+
+module MiniAutobot
+  module Utils
+
+    module Castable
+
+      module ClassMethods
+
+        # Attempts to create a new page object from a driver state. Use the
+        # instance method for convenience. Raises `NameError` if the page could
+        # not be found.
+        #
+        # @param driver [Selenium::WebDriver] The instance of the current
+        #   WebDriver.
+        # @param name [#to_s] The name of the page object to instantiate.
+        # @return [Base] A subclass of `Base` representing the page object.
+        # @raise InvalidPageState if the page cannot be casted to
+        # @raise NameError if the page object doesn't exist
+        def cast(driver, name)
+          # Transform the name string into a file path and then into a module name
+          klass_name = "mini_autobot/page_objects/#{name}".camelize
+
+          # Attempt to load the class
+          klass = begin
+            klass_name.constantize
+          rescue => exc
+            msg = ""
+            msg << "Cannot find page object '#{name}', "
+            msg << "because could not load class '#{klass_name}' "
+            msg << "with underlying error:\n  #{exc.class}: #{exc.message}\n"
+            msg << exc.backtrace.map { |str| "    #{str}" }.join("\n")
+            raise NameError, msg
+          end
+
+          # Instantiate the class, passing the driver automatically, and
+          # validates to ensure the driver is in the correct state
+          instance = klass.new(driver)
+          begin
+            instance.validate!
+          rescue Minitest::Assertion => exc
+            raise MiniAutobot::PageObjects::InvalidePageState, "#{klass}: #{exc.message}"
+          end
+          instance
+        end
+
+      end
+
+      # Extend the base class in which this module is included in order to
+      # inject class methods.
+      #
+      # @param base [Class]
+      # @return [void]
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # The preferred way to create a new page object from the current page's
+      # driver state. Raises a NameError if the page could not be found. If
+      # casting causes a StaleElementReferenceError, the method will retry up
+      # to 2 more times.
+      #
+      # @param name [String] see {Base.cast}
+      # @return [Base] The casted page object.
+      # @raise InvalidPageState if the page cannot be casted to
+      # @raise NameError if the page object doesn't exist
+      def cast(name)
+        tries ||= 3
+        self.class.cast(@driver, name).tap do |new_page|
+          self.freeze
+          MiniAutobot.logger.debug("Casting #{self.class}(##{self.object_id}) into #{new_page.class}(##{new_page.object_id})")
+        end
+      rescue Selenium::WebDriver::Error::StaleElementReferenceError => sere
+        MiniAutobot.logger.debug("#{self.class}(##{@driver.object_id})->cast(#{name}) raised a potentially-swallowed StaleElementReferenceError")
+        sleep 1
+        retry unless (tries -= 1).zero?
+      end
+
+      # Cast the page to any of the listed `names`, in order of specification.
+      # Returns the first page that accepts the casting, or returns nil, rather
+      # than raising InvalidPageState.
+      #
+      # @param names [Enumerable<String>] see {Base.cast}
+      # @return [Base, nil] the casted page object, if successful; nil otherwise.
+      # @raise NameError if the page object doesn't exist
+      def cast_any(*names)
+        # Try one at a time, swallowing InvalidPageState exceptions
+        names.each do |name|
+          begin
+            return self.cast(name)
+          rescue InvalidPageState
+            # noop
+          end
+        end
+
+        # Return nil otherwise
+        return nil
+      end
+
+    end
+
+  end
+end
+

data/lib/mini_autobot/utils/data_generator_helper.rb

@@ -0,0 +1,145 @@
+
+module MiniAutobot
+  module Utils
+
+    # Useful helpers to generate fake data.
+    module DataGeneratorHelper
+
+      # All valid area codes in the US
+      NPA = ["201", "202", "203", "205", "206", "207", "208", "209", "210", "212", "213", "214", "215", "216", "217", "218", "219", "224", "225", "227", "228", "229", "231", "234", "239", "240", "248", "251", "252", "253", "254", "256", "260", "262", "267", "269", "270", "276", "281", "283", "301", "302", "303", "304", "305", "307", "308", "309", "310", "312", "313", "314", "315", "316", "317", "318", "319", "320", "321", "323", "330", "331", "334", "336", "337", "339", "347", "351", "352", "360", "361", "386", "401", "402", "404", "405", "406", "407", "408", "409", "410", "412", "413", "414", "415", "417", "419", "423", "424", "425", "434", "435", "440", "443", "445", "464", "469", "470", "475", "478", "479", "480", "484", "501", "502", "503", "504", "505", "507", "508", "509", "510", "512", "513", "515", "516", "517", "518", "520", "530", "540", "541", "551", "557", "559", "561", "562", "563", "564", "567", "570", "571", "573", "574", "580", "585", "586", "601", "602", "603", "605", "606", "607", "608", "609", "610", "612", "614", "615", "616", "617", "618", "619", "620", "623", "626", "630", "631", "636", "641", "646", "650", "651", "660", "661", "662", "667", "678", "682", "701", "702", "703", "704", "706", "707", "708", "712", "713", "714", "715", "716", "717", "718", "719", "720", "724", "727", "731", "732", "734", "737", "740", "754", "757", "760", "763", "765", "770", "772", "773", "774", "775", "781", "785", "786", "801", "802", "803", "804", "805", "806", "808", "810", "812", "813", "814", "815", "816", "817", "818", "828", "830", "831", "832", "835", "843", "845", "847", "848", "850", "856", "857", "858", "859", "860", "862", "863", "864", "865", "870", "872", "878", "901", "903", "904", "906", "907", "908", "909", "910", "912", "913", "914", "915", "916", "917", "918", "919", "920", "925", "928", "931", "936", "937", "940", "941", "947", "949", "952", "954", "956", "959", "970", "971", "972", "973", "975", "978", "979", "980", "984", "985", "989"]
+
+      # Easier to assume for now a list of valid exchanges
+      NXX = NPA
+
+      # Generate a string of random digits.
+      #
+      # @param digits [Fixnum] the number of digits in the string
+      # @return [String] the string of digits
+      def generate_digits(digits = 1)
+        Faker::Number.number(digits)
+      end
+
+      # Generate a random email address.
+      #
+      # The specifier portion may be:
+      #
+      # * `nil`, in which case nothing special happens;
+      # * a `String`, in which case the words in the string is shuffled, and
+      #   random separators (`.` or `_`) are inserted between them;
+      # * an `Integer`, in which case a random alpha-string will be created
+      #   with length of at least that many characters;
+      # * a `Range`, in which case a random alpha-string of length within the
+      #   range will be produced.
+      #
+      # @param specifier [nil, String, Integer, Range] a specifier to help
+      #   generate the username part of the email address
+      # @return [String]
+      def generate_email(specifier = nil)
+        Faker::Internet.email(name)
+      end
+
+      # Generate a handsome first name.
+      #
+      # @param length [#to_i, nil]
+      # @return [String]
+      def generate_first_name(length = nil)
+        first_name = ''
+        if length.nil?
+          first_name = Faker::Name.first_name
+        else
+          # Ensure a name with requested length is generated
+          name_length = Faker::Name.first_name.length
+          if length > name_length
+            first_name = Faker::Lorem.characters(length)
+          else
+            first_name = Faker::Name.first_name[0..length.to_i]
+          end
+        end
+        # remove all special characters since name fields on our site have this requirement
+        first_name.gsub!(/[^0-9A-Za-z]/, '')
+        first_name
+      end
+
+      # Generate a gosh-darn awesome last name.
+      #
+      # @param length [#to_i, nil]
+      # @return [String]
+      def generate_last_name(length = nil)
+        last_name = ''
+        if length.nil?
+          last_name = Faker::Name.last_name
+        else
+          # Ensure a name with requested length is generated
+          name_length = Faker::Name.last_name.length
+          if length > name_length
+            last_name = Faker::Lorem.characters(length)
+          else
+            last_name = Faker::Name.last_name[0..length.to_i]
+          end
+        end
+        # remove all special characters since name fields on our site have this requirement
+        last_name.gsub!(/[^0-9A-Za-z]/, '')
+        last_name
+      end
+
+      # Generate a unique random email ends with @test.com
+      def generate_test_email
+        [ "#{generate_last_name}.#{generate_unique_id}", 'test.com' ].join('@')
+      end
+
+      # Generate a random number between 0 and `max - 1` if `max` is >= 1,
+      # or between 0 and 1 otherwise.
+      def generate_number(max = nil)
+        rand(max)
+      end
+
+      # Generates a U.S. phone number (NANPA-aware).
+      #
+      # @param format [Symbol, nil] the format of the phone, one of: nil,
+      #   `:paren`, `:dotted`, or `:dashed`
+      # @return [String] the phone number
+      def generate_phone_number(format = nil)
+        case format
+        when :paren, :parenthesis, :parentheses
+          '(' + NPA.sample + ') ' + NXX.sample + '-' + generate_digits(4)
+        when :dot, :dotted, :dots, :period, :periods
+          [ NPA.sample, NXX.sample, generate_digits(4) ].join('.')
+        when :dash, :dashed, :dashes
+          [ NPA.sample, NXX.sample, generate_digits(4) ].join('-')
+        else
+          NPA.sample + NXX.sample + generate_digits(4)
+        end
+      end
+
+      # Generate a random date.
+      #
+      # @param start_date [Integer] minimum date range
+      # @param end_date [Integer] maximum date range
+      # @return [String] the generated date
+      def generate_date(start_date, end_date)
+        random_date = rand start_date..end_date
+        return random_date.to_formatted_s(:month_day_year)
+      end
+      
+      # Generate a unique id with a random hex string and time stamp string
+      def generate_unique_id
+        SecureRandom.hex(3) + Time.current.to_i.to_s
+      end
+
+      # Generate a random password of a certain length, or default length 12
+      #
+      # @param length [#to_i, nil]
+      # @return [String]
+      def generate_password(length = nil)
+        if length.nil?
+          SecureRandom.hex(6) # result length = 12
+        else
+          chars = (('a'..'z').to_a + ('0'..'9').to_a) - %w(i o 0 1 l 0)
+          (1..length).collect{|a| chars[rand(chars.length)] }.join
+        end
+      end
+
+    end
+
+  end
+end

data/lib/mini_autobot/utils/endeca_helper.rb

@@ -0,0 +1,46 @@
+
+module MiniAutobot
+  module Utils
+
+    # Page object-related helper methods.
+    module EndecaHelper
+
+      # Helper method to instantiate a new page object. This method should only
+      # be used when first loading; subsequent page objects are automatically
+      # instantiated by calling #cast on the page object.
+      #
+      # @param name [String, Symbol]
+      # @return [PageObject::Base]
+      def endeca(name)
+        # Get the fully-qualified class name
+        klass_name = "mini_autobot/database/endeca".camelize
+        klass = begin
+          klass_name.constantize
+        rescue => exc
+          msg = ""
+          msg << "Cannot find page object '#{name}', "
+          msg << "because could not load class '#{klass_name}' "
+          msg << "with underlying error:\n  #{exc.class}: #{exc.message}\n"
+          msg << exc.backtrace.map { |str| "    #{str}" }.join("\n")
+          raise NameError, msg
+          
+        driver = MiniAutobot::Connector.get_default
+        instance = klass.new(driver)
+        
+        Drawbridge.setup do |config|
+          config.bridge_url = driver.env[:endeca][:url]
+          config.bridge_path = driver.env[:endeca][:bridge]
+          # e.g. ENDECA_DEBUG=true rackup
+          config.endeca_debug = ENV.fetch('ENDECA_DEBUG') { false }
+          # optional, default is 5
+          config.timeout = 5
+          # optional, default is to change ' into &#39; before JSON is parsed
+          config.skip_single_quote_encoding = true
+        end
+        
+        return instance
+       end        
+      end
+     end
+  end
+end

data/lib/mini_autobot/utils/loggable.rb

@@ -0,0 +1,16 @@
+
+module MiniAutobot
+  module Utils
+
+    # Module that injects a convenience method to access the logger.
+    module Loggable
+
+      # Convenience instance method to access the default logger.
+      def logger
+        MiniAutobot.logger
+      end
+
+    end
+
+  end
+end

data/lib/mini_autobot/utils/overlay_and_widget_helper.rb

@@ -0,0 +1,78 @@
+module MiniAutobot
+  module Utils
+    module OverlayAndWidgetHelper
+      # Create widgets of type `name` from `items`, where `name` is the widget
+      # class name, and `items` is a single or an array of WebDriver elements.
+      #
+      # @param name [#to_s] the name of the widget, under `mini_autobots/page_objects/widgets`
+      #   to load.
+      # @param items [Enumerable<Selenium::WebDriver::Element>] WebDriver elements.
+      # @return [Enumerable<MiniAutobot::PageObjects::Widgets::Base>]
+      # @raise NameError
+      def get_widgets!(name, items)
+        items = Array(items)
+        return [] if items.empty?
+
+        # Load the widget class
+        klass_name = "mini_autobot/page_objects/widgets/#{name}".camelize
+        klass = begin
+          klass_name.constantize
+        rescue => exc
+          msg = ""
+          msg << "Cannot find widget '#{name}', "
+          msg << "because could not load class '#{klass_name}' "
+          msg << "with underlying error:\n  #{exc.class}: #{exc.message}\n"
+          msg << exc.backtrace.map { |str| "    #{str}" }.join("\n")
+          raise NameError, msg
+        end
+
+        page = self.page_object
+
+        if items.respond_to?(:map)
+          items.map { |item| klass.new(page, item) }
+        else
+          [klass.new(page, items)]
+        end
+      end
+
+      # Create overlay of type `name`, where `name` is the overlay
+      # class name
+      #
+      # @param name [#to_s] the name of the overlay, under `mini_autobots/page_objects/widgets`
+      #   to load.
+      # @param items [Enumerable<Selenium::WebDriver::Element>] WebDriver elements.
+      # @return [Enumerable<MiniAutobot::PageObjects::Overlay::Base>]
+      # @raise NameError
+      def get_overlay!(name)
+        # Load the Overlay class
+        klass_name = "mini_autobot/page_objects/overlay/#{name}".camelize
+        klass = begin
+          klass_name.constantize
+        rescue => exc
+          msg = ""
+          msg << "Cannot find overlay '#{name}', "
+          msg << "because could not load class '#{klass_name}' "
+          msg << "with underlying error:\n  #{exc.class}: #{exc.message}\n"
+          msg << exc.backtrace.map { |str| "    #{str}" }.join("\n")
+          raise NameError, msg
+        end
+        page = self.page_object
+        instance = klass.new(page)
+        # Overlay is triggered to show when there's certain interaction on the page
+        # So validate! is necessary for loading some elements on some overlays
+        begin
+          instance.validate!
+        rescue Minitest::Assertion => exc
+          raise MiniAutobot::PageObjects::InvalidePageState, "#{klass}: #{exc.message}"
+        end
+        instance
+      end
+
+
+      def page_object
+        raise NotImplementedError, "classes including OverlayAndWidgetHelper must override :page_object"
+      end
+
+    end #OverlayAndWidgetHelper
+  end #Utils
+end #MiniAutobot

data/lib/mini_autobot/utils/page_object_helper.rb

@@ -0,0 +1,209 @@
+
+module MiniAutobot
+  module Utils
+
+    # Page object-related helper methods.
+    module PageObjectHelper
+
+      # Helper method to instantiate a new page object. This method should only
+      # be used when first loading; subsequent page objects are automatically
+      # instantiated by calling #cast on the page object.
+      #
+      # Pass optional parameter Driver, which can be initialized in test and will override the global driver here.
+      #
+      # @param name [String, Driver]
+      # @return [PageObject::Base]
+      def page(name, override_driver=nil)
+        # Get the fully-qualified class name
+        klass_name = "mini_autobot/page_objects/#{name}".camelize
+        klass = begin
+          klass_name.constantize
+        rescue => exc
+          msg = ""
+          msg << "Cannot find page object '#{name}', "
+          msg << "because could not load class '#{klass_name}' "
+          msg << "with underlying error:\n  #{exc.class}: #{exc.message}\n"
+          msg << exc.backtrace.map { |str| "    #{str}" }.join("\n")
+          raise NameError, msg
+        end
+
+        # Get a default connector
+        @driver = MiniAutobot::Connector.get_default if override_driver.nil?
+        @driver = override_driver if !override_driver.nil?
+        instance = klass.new(@driver)
+
+        # Before visiting the page, do any pre-processing necessary, if any,
+        # but only visit the page if the pre-processing succeeds
+        if block_given?
+          retval = yield instance
+          instance.go! if retval
+        else
+          instance.go! if override_driver.nil?
+        end
+
+        # similar like casting a page, necessary to validate some element on a page
+        begin
+          instance.validate!
+        rescue Minitest::Assertion => exc
+          raise MiniAutobot::PageObjects::InvalidePageState, "#{klass}: #{exc.message}"
+        end
+
+        # Return the instance as-is
+        instance
+      end
+
+      # Local teardown for page objects. Any page objects that are loaded will
+      # be finalized upon teardown.
+      #
+      # @return [void]
+      def teardown
+        if !passed? && !skipped? && !@driver.nil?
+          take_screenshot
+          print_sauce_link if connector_is_saucelabs?
+        end
+        begin
+          set_sauce_session_name if connector_is_saucelabs? && !@driver.nil?
+          self.logger.debug "Finished setting saucelabs session name for #{name()}"
+        rescue
+          self.logger.debug "Failed setting saucelabs session name for #{name()}"
+        end
+
+        MiniAutobot::Connector.finalize!
+        super
+      end
+
+      def take_screenshot
+        @driver.save_screenshot("logs/#{name}.png")
+      end
+
+      # Print out a link of a saucelabs's job when a test is not passed
+      # Rescue to skip this step for tests like cube tracking
+      def print_sauce_link
+        begin
+          puts "Find test on saucelabs: https://saucelabs.com/tests/#{@driver.session_id}"
+        rescue
+          puts 'can not retrieve driver session id, no link to saucelabs'
+        end
+      end
+
+      # update session name on saucelabs
+      def set_sauce_session_name
+        # identify the user who runs the tests and grab user's access_key
+        # where are we parsing info from run command to in the code?
+        connector = MiniAutobot.settings.connector # eg. saucelabs:phu:win7_ie11
+        overrides = connector.to_s.split(/:/)
+        new_tags = overrides[2]+"_by_"+overrides[1]
+        file_name = overrides.shift
+        path = MiniAutobot.root.join('config/mini_autobot', 'connectors')
+        filepath  = path.join("#{file_name}.yml")
+        raise ArgumentError, "Cannot load profile #{file_name.inspect} because #{filepath.inspect} does not exist" unless filepath.exist?
+
+        cfg = YAML.load(File.read(filepath))
+        cfg = Connector.resolve(cfg, overrides)
+        cfg.freeze
+        username = cfg["hub"]["user"]
+        access_key = cfg["hub"]["pass"]
+
+        require 'json'
+        session_id = @driver.session_id
+        http_auth = "https://#{username}:#{access_key}@saucelabs.com/rest/v1/#{username}/jobs/#{session_id}"
+        # to_json need to: require "active_support/core_ext", but will mess up the whole framework, require 'json' in this method solved it
+        body = {"name" => name(), "tags" => [new_tags]}.to_json
+        # gem 'rest-client'
+        RestClient.put(http_auth, body, {:content_type => "application/json"})
+      end
+      
+      def connector_is_saucelabs?
+        return true if MiniAutobot.settings.connector.include?('saucelabs')
+        return false
+      end
+
+      # Generic page object helper method to clear and send keys to a web element found by driver
+      # @param [Element, String]
+      def put_value(web_element, value)
+        web_element.clear
+        web_element.send_keys(value)
+      end
+
+      # Helper method for retrieving value from yml file
+      # todo should be moved to FileHelper.rb once we created this file in utils
+      # @param [String, String]
+      # keys, eg. "timeouts:implicit_wait"
+      def read_yml(file_name, keys)
+        data = Hash.new
+        begin
+          data = YAML.load_file "#{file_name}"
+        rescue
+          raise Exception, "File #{file_name} doesn't exist" unless File.exist?(file_name)
+        rescue
+          raise YAMLErrors, "Failed to load #{file_name}"
+        end
+        keys_array = keys.split(/:/)
+        value = data
+        keys_array.each do |key|
+          value = value[key]
+        end
+        return value
+      end
+
+      # Check if a web element exists on page or not, without wait
+      def is_element_present?(how, what, driver = nil)
+        element_appeared?(how, what, driver)
+      end
+
+      # Check if a web element exists and displayed on page or not, without wait
+      def is_element_present_and_displayed?(how, what, driver = nil)
+        element_appeared?(how, what, driver, check_display = true)
+      end
+
+      private
+
+      # @param  eg. (:css, 'button.cancel') or (*BUTTON_SUBMIT_SEARCH)
+      # @param  also has an optional parameter-driver, which can be @element when calling this method in a widget object
+      # @return [boolean]
+      def element_appeared?(how, what, driver = nil, check_display = false)
+        original_timeout = read_yml("config/mini_autobot/connectors/saucelabs.yml", "timeouts:implicit_wait")
+        @driver.manage.timeouts.implicit_wait = 0
+        result = false
+        parent_element = @driver if driver == nil
+        parent_element = driver if driver != nil
+        elements = parent_element.find_elements(how, what)
+        if check_display
+          begin
+            result = true if elements.size() > 0 && elements[0].displayed?
+          rescue
+            result = false
+          end
+        else
+          result = true if elements.size() > 0
+        end
+        @driver.manage.timeouts.implicit_wait = original_timeout
+        return result
+      end
+
+      def wait_for_element_to_display(how, what, friendly_name = "element")
+          wait(timeout: 15, message: "Timeout waiting for #{friendly_name} to display")
+            .until {is_element_present_and_displayed?(how, what)}
+      end
+
+      def wait_for_element_to_be_present(how, what, friendly_name = "element")
+        wait(timeout: 15, message: "Timeout waiting for #{friendly_name} to be present")
+          .until {is_element_present?(how, what)}
+      end
+
+      # Useful when you want to wait for the status of an element attribute to change
+      # Example: the class attribute of <body> changes to include 'logged-in' when a user signs in to rent.com
+      # Example usage: wait_for_attribute_status_change(:css, 'body', 'class', 'logged-in', 'sign in')
+      def wait_for_attribute_to_have_value(how, what, attribute, value, friendly_name = "attribute")
+        wait(timeout: 15, message: "Timeout waiting for #{friendly_name} status to update")
+          .until { driver.find_element(how, what).attribute(attribute).include?(value) rescue retry }
+      end
+
+      def current_page(calling_page)
+        calling_page.class.to_s.split('::').last.downcase
+      end
+
+    end
+
+  end
+end