robotest 1.0.2

data/lib/robotest/driver.rb

@@ -0,0 +1,355 @@
+module RoboTest
+
+  class Driver
+    attr_accessor :driver
+    $focus_driver = nil
+    @driver = nil
+    @main_window = nil
+    @click_exception_count = nil
+    @@drivers = []
+    @@drivers_with_names = {}
+
+    def initialize(driver_name = "Driver", browser = $conf['browser'], opts = {})
+      begin
+        start(driver_name,browser, opts)
+        puts "#{driver_name} is initialized"
+      rescue Exception => e
+        puts "#{driver_name} is failed to initialize \nRetrying to initialize #{driver_name}"
+        start(driver_name,browser, opts)
+        puts "#{driver_name} is initialized after an exception"
+      end
+    end
+
+    ##############################
+    # Custom methods of robotest #
+    ##############################
+
+    def start(driver_name, browser, opts = {})
+      dimensions = $conf['dimensions']
+
+      if (!dimensions['horizontal'] or !dimensions['vertical'])
+        dimensions = {'horizontal' => 1366, 'vertical' => 768}
+      end
+
+      if (!$conf['implicit_wait'])
+        puts "Specify implicit_wait for your project in the .yml files"
+        $conf['implicit_wait'] = 20
+      end
+
+      prefs = {}
+      if opts.empty?
+        switches = $conf['switches']
+        prefs = $conf['prefs'] if $conf.key?('prefs')
+      elsif opts.key?(:switches)
+        switches = opts[:switches]
+      elsif opts.key?(:prefs)
+        prefs = opts[:prefs]
+      end
+
+      case browser
+
+      when 'firefox', 'ff'
+        options = Selenium::WebDriver::Firefox::Options.new
+        switches.map { |k| options.add_argument(k) }
+        if prefs['profile']
+          if prefs['profile']['name']
+            profile = Selenium::WebDriver::Firefox::Profile.from_name(prefs['profile']['name'])
+            options.profile = profile
+          end
+        end
+        if prefs['download']
+          options.add_preference("browser.download.folderList", 2)
+          options.add_preference("browser.download.dir", "#{Pathname.pwd}/#{prefs['download']['default_directory']}")
+          options.add_preference("browser.download.manager.alertOnEXEOpen", false)
+          options.add_preference("browser.helperApps.neverAsk.saveToDisk" , "application/msword,application/csv,text/csv,image/png ,image/jpeg, application/pdf, text/html,text/plain,application/octet-stream")
+        end
+        caps = Selenium::WebDriver::Remote::Capabilities.firefox(
+          'marionette' => true,
+          'moz:useNonSpecCompliantPointerOrigin' => false,
+          'moz:webdriverClick' => false
+        )
+        @driver = Selenium::WebDriver.for :firefox, :desired_capabilities => caps, options: options
+        
+      when 'ie', 'internet_explorer'
+        caps = Selenium::WebDriver::Remote::Capabilities.internet_explorer('ie.ensureCleanSession' => true, 'ie.browserCommandLineSwitches' => 'private')
+        @driver = Selenium::WebDriver.for(:internet_explorer, :desired_capabilities => caps)
+
+      when 'edge'
+        @driver = Selenium::WebDriver.for :edge
+
+      when 'chrome'
+        options = Selenium::WebDriver::Chrome::Options.new
+        # options.add_preference(:download, prefs["download"]) if prefs["download"]
+        if prefs
+          prefs.each do |key, value|
+            options.add_preference(key, value)
+          end
+        end
+
+        if opts.key?(:extension)
+          options.add_extension(opts[:extension])
+        end
+        switches.map { |k| options.add_argument(k) }
+        @driver = Selenium::WebDriver.for(:chrome, options: options)
+        if prefs["download"]
+          enable_chrome_headless_downloads("#{Pathname.pwd}/#{prefs["download"]["default_directory"]}")
+        else
+          enable_chrome_headless_downloads(Pathname.pwd)
+          puts "WARNING: Download path is set to the current root folder if it is not specified in the config file.\nExample: "
+          puts "prefs:
+                    download:
+                      default_directory: downloads/"
+        end
+
+      when 'safari'
+        @driver = Selenium::WebDriver.for(:safari, opts)
+
+      else
+        raise ArgumentError, "Specify a proper browser while initiating a driver \n \n#{browser.inspect}"
+      end
+
+      target_size = Selenium::WebDriver::Dimension.new(dimensions["horizontal"], dimensions["vertical"])
+      @driver.manage.window.size = target_size
+      @click_exception_count=0
+      @@drivers.push(self)
+      @@drivers_with_names[self] = "#{driver_name}"
+      $focus_driver = self
+      puts "#{driver_name} - #{self}"
+      return self
+    end
+
+    def enable_chrome_headless_downloads(directory)
+      bridge = @driver.send(:bridge)
+      path = '/session/:session_id/chromium/send_command'
+      path[':session_id'] = bridge.session_id
+      bridge.http.call(:post, path, {
+                         "cmd" => "Page.setDownloadBehavior",
+                         "params" => {
+                           "behavior" => "allow",
+                           "downloadPath" => directory,
+                         }
+      })
+    end
+
+    def get(url)
+      $focus_driver = self
+      @driver.get(url)
+      puts "#{$focus_driver} loaded with - #{url}"
+    end
+
+    def refresh
+      $focus_driver = self
+      navigate.refresh
+      puts "#{$focus_driver} is refreshed"
+    end
+
+    def find_element(locator)
+      $focus_driver = self
+      RoboTest::Wait.wait_for_element(locator)
+      return @driver.find_element(locator.how,locator.what)
+    end
+
+    def find_elements(locator)
+      $focus_driver = self
+      return @driver.find_elements(locator.how,locator.what)
+    end
+
+    def mouse_over(locator,index=1)
+      $focus_driver = self
+      element=find_elements(locator)[index-1]
+      @driver.action.move_to(element).perform
+      puts "mouse over for the element - #{locator.how} => #{locator.what} is done"
+    end
+
+    def mouse
+      $focus_driver = self
+      return @driver.mouse
+    end
+
+    def action
+      $focus_driver = self
+      return @driver.action
+    end
+
+    def move_and_click(locator)
+      $focus_driver = self
+      ele=find_element(locator)
+      @driver.action.move_to(ele).click.perform
+      puts "Mouse over the locator and then click for - #{locator.how} => #{locator.what} is done"
+    end
+
+    def browser
+      $focus_driver = self
+      @driver.browser
+    end
+
+    def capabilities
+      $focus_driver = self
+      @driver.capabilities
+    end
+
+    def current_url
+      $focus_driver = self
+      @driver.current_url
+    end
+
+    def execute_async_script(script, *args)
+      $focus_driver = self
+      @driver.execute_async_script(script, *args)
+    end
+
+    def execute_script(script)
+      $focus_driver = self
+      @driver.execute_script(script)
+    end
+
+    def inspect
+      $focus_driver = self
+      @driver.inspect
+    end
+
+    def manage
+      $focus_driver = self
+      @driver.manage
+    end
+
+    def navigate
+      $focus_driver = self
+      @driver.navigate
+    end
+
+    def page_source
+      $focus_driver = self
+      @driver.page_source
+    end
+
+    def body_text
+      $focus_driver = self
+      @driver.find_element(:css, 'body').text
+    end
+
+    def save_screenshot(file_name = nil)
+      $focus_driver = self
+      file_name = "#{Pathname.pwd}/#{$conf['screenshot_location']}/#{Time.new.strftime("%Y-%m-%d-%H-%M-%S-%L-%N")}.png" if file_name.nil?
+      puts "#{$focus_driver}'s Screenshot saved in this path => #{file_name}"
+      @driver.save_screenshot(file_name)
+    end
+
+    def switch_to_frame(locator)
+      $focus_driver = self
+      @main_window=@driver.window_handle
+      @driver.switch_to.frame(find_element(locator))
+      puts "Switched to iframe - #{locator.how} => #{locator.what} on #{$focus_driver}"
+      return @main_window
+    end
+
+    def switch_to_window(locator=nil)
+      $focus_driver = self
+      @main_window=@driver.window_handle
+      locator.click if locator != nil
+      windows=@driver.window_handles
+      new_window=nil;
+      windows.length.times do |i|
+        if windows[i] != @main_window
+          new_window=windows[i]
+        end
+      end
+      @driver.switch_to.window(new_window)
+      puts "Switched to new window on #{$focus_driver}"
+      return @main_window
+    end
+
+    def scroll_to_locator(locator)
+      $focus_driver = self
+      element = find_element(locator)
+      @driver.execute_script("arguments[0].scrollIntoView({behavior: 'smooth', block: 'center', inline: 'nearest'});",element)
+      puts "Scroll to this locator - #{locator.how} => #{locator.what} on #{$focus_driver}"
+      sleep 1
+    end
+
+    def revert_to(window=nil)
+      $focus_driver = self
+      if window != nil
+        @driver.switch_to.window(window)
+        puts "Switched back to another window - #{window} in #{$focus_driver}"
+      else
+        @driver.switch_to.window(@main_window)
+        puts "Switched back to main window in #{focus_driver}"
+      end
+    end
+
+    def close
+      $focus_driver = self
+      @driver.close
+      puts "Closed the browser - #{$focus_driver}"
+    end
+
+    def quit
+      @driver.quit
+      @@drivers.delete(self)
+      $focus_driver = @@drivers[0]
+      puts "Quit the browser - #{$focus_driver}"
+    end
+
+    def quit_all
+      @@drivers.each do |driver|
+        driver.quit if driver != self
+      end
+      self.quit
+      puts "deleted all the browsers"
+    end
+
+    def self.quit_all_drivers
+      @@drivers.each do |driver|
+        driver.quit if driver != self
+      end
+      puts "deleted all the browsers"
+    end
+
+    def self.get_all_drivers
+      return @@drivers_with_names
+    end
+
+    def alert(ok_cancel)
+      sleep 2
+      alert = @driver.switch_to.alert
+      alertMsg=alert.text
+      if ok_cancel
+        alert.accept
+        puts "The alert was accepted in #{$focus_driver} with alert message #{alertMsg}"
+      else
+        alert.dismiss
+        puts "The alert was dismissed in #{$focus_driver} with alert message #{alertMsg}"
+      end
+      return alertMsg
+    end
+
+    def is_alert_present?
+      begin
+        alert = @driver.switch_to.alert
+        alertMsg=alert.text
+        return true
+      rescue Exception => e
+        return false
+      end
+    end
+
+    def self.switch_to(driver)
+      $focus_driver = driver
+    end
+
+    def drag_and_drop(source_locator, target_locator)
+      source = find_element(source_locator)
+      target = find_element(target_locator)
+      @driver.action.click_and_hold(source).perform
+      @driver.action.move_to(target).release.perform
+      sleep 3
+      puts "In driver #{$focus_driver} - #{source_locator.how} => source_locator.what locator was dragged and moved to this locator #{target_locator.how} => #{target_locator.what}"
+    end
+
+    def on
+      $focus_driver = self
+      yield
+    end
+  end
+end

data/lib/robotest/dsl.rb

@@ -0,0 +1,69 @@
+module AllureRSpec
+  module DSL
+    module Example
+
+      @@step_count = 0
+      @@current_example_location = nil
+
+      def step(step, *tags, &block)
+        __increment_step_count
+        metadata[:step_group] ||= {}
+        tags = tags[0].nil? ? {} : tags[0]
+        metadata[:step_group][@@step_count] = tags
+        metadata[:step_name] = step
+
+        suite = __description(metadata[:example_group])
+        test = __description(metadata)
+        begin
+          AllureRubyAdaptorApi::Builder.start_step(suite, test, step)
+          __with_step step, &block
+          __set_step_status('passed')
+          AllureRubyAdaptorApi::Builder.stop_step(suite, test, step)
+        rescue Exception => e
+          __set_step_status('failed')
+          AllureRubyAdaptorApi::Builder.stop_step(suite, test, step, :failed)
+          raise e
+        end
+      end
+
+      def cstep(step, *tags, &block) # to run even after failure
+        __increment_step_count
+        metadata[:step_group] ||= {}
+        tags = tags[0].nil? ? {} : tags[0]
+        metadata[:step_group][@@step_count] = tags
+        metadata[:step_name] = step
+
+        suite = __description(metadata[:example_group])
+        test = __description(metadata)
+        begin
+          AllureRubyAdaptorApi::Builder.start_step(suite, test, step)
+          __with_step step, &block
+          __set_step_status('passed')
+          AllureRubyAdaptorApi::Builder.stop_step(suite, test, step)
+        rescue Exception => e
+          __set_step_status('failed')
+          AllureRubyAdaptorApi::Builder.stop_step(suite, test, step, :failed)
+        end
+      end
+
+      private
+
+      def __increment_step_count
+        if @@current_example_location != metadata[:location]
+          __reset_step_count
+          @@current_example_location = metadata[:location]
+        else
+          @@step_count += 1
+        end
+      end
+
+      def __reset_step_count
+        @@step_count = 0
+      end
+
+      def __set_step_status(status)
+        metadata[:step_group][@@step_count][:status] = status
+      end
+    end
+  end
+end

data/lib/robotest/locator.rb

@@ -0,0 +1,204 @@
+module RoboTest
+  class Locator
+
+    attr_accessor :how
+    attr_accessor :what
+    attr_accessor :options
+
+    def initialize(
+        how,
+        what,
+        options = {
+          "hidden" => false,
+          "ajax_load" => false
+        }
+      )
+      @how = how
+      @what = what
+      @options = options
+    end
+
+    def options(driver = $focus_driver)
+      @options
+    end
+
+    ##################################################
+    # Methods inherited and overriden from Selenium  #
+    ##################################################
+
+    def click(driver = $focus_driver)
+      begin
+        driver.find_element(self).click
+        puts "Clicked - #{self.how} => #{self.what}"
+      rescue Exception => e
+        if(e.message.include?("is not clickable at point") || e.message.include?("element not visible") || e.message.include?("stale element reference"))
+          sleep 3
+          locator = Locator.new(@how,@what,@options)
+          locator.click
+        else
+          puts "Not clicked at - #{self.how} => #{self.what}"
+          puts e.message
+        end
+      end
+    end
+
+    def text(driver = $focus_driver)
+      return driver.find_element(self).text
+    end
+
+    def texts(driver = $focus_driver)
+      elements_text = []
+      driver.find_elements(self).each do |element|
+        elements_text.push(element.text)
+      end
+      return elements_text
+    end
+
+    def attribute(name, driver = $focus_driver)
+      driver.find_element(self).attribute(name)
+    end
+
+    def css_value(prop, driver = $focus_driver)
+      driver.find_element(self).css_value(prop)
+    end
+
+    def displayed?(driver = $focus_driver)
+      driver.find_element(self).displayed?
+    end
+
+    def enabled?(driver = $focus_driver)
+      driver.find_element(self).enabled?
+    end
+
+    def is_enabled_with_wait?(timeout=$conf["implicit_wait"], driver = $focus_driver)
+      index=0
+      while driver.find_element(self).enabled? == false
+        sleep 1
+        break if index == timeout
+        index+=1
+      end
+    end
+
+    def hash(driver = $focus_driver)
+      driver.find_element(self).hash
+    end
+
+    def location(driver = $focus_driver)
+      driver.find_element(self).location
+    end
+
+    def location_once_scrolled_into_view(driver = $focus_driver)
+      driver.find_element(self).location_once_scrolled_into_view
+    end
+
+    def property(driver = $focus_driver)
+      driver.find_element(self).property
+    end
+
+    def selected?(driver = $focus_driver)
+      driver.find_element(self).selected?
+    end
+
+    def size(driver = $focus_driver)
+      driver.find_element(self).size
+    end
+
+    def style(prop, driver = $focus_driver)
+      driver.find_element(self).style(prop)
+    end
+
+    def submit(driver = $focus_driver)
+      driver.find_element(self).submit
+    end
+
+    def tag_name(driver = $focus_driver)
+      driver.find_element(self).tag_name
+    end
+
+    def is_present?(driver=$focus_driver)
+      driver.driver.manage.timeouts.implicit_wait = 0
+      begin
+        return driver.driver.find_element(self.how,self.what).displayed?
+      rescue Exception => e
+        driver.driver.manage.timeouts.implicit_wait = $conf["implicit_wait"]
+        return false
+      ensure
+        driver.driver.manage.timeouts.implicit_wait = $conf["implicit_wait"]
+      end
+    end
+
+    def is_present_with_wait?(timeout=$conf["implicit_wait"],driver=$focus_driver)
+      Wait.wait_for_element(self,timeout,driver)
+      is_present?(driver)
+    end
+
+    def is_not_present_with_wait?(timeout=$conf["implicit_wait"],driver=$focus_driver)
+      Wait.wait_for_element_hide(self,timeout,driver)
+      return !is_present?(driver)
+    end
+
+    def click_if_present(driver = $focus_driver)
+      click(driver) if is_present?(driver)
+    end
+
+    def click_if_present_with_wait(timeout = $conf["implicit_wait"], driver = $focus_driver)
+      click(driver) if is_present_with_wait?(timeout, driver)
+    end
+
+    def to_s
+      return "How ===> #{@how}\nWhat ===> #{@what}\nOptions ===> #{@options}"
+    end
+
+    def mouse_over(index = 1, driver = $focus_driver)
+      element = driver.find_elements(self)[index-1]
+      driver.action.move_to(element).perform
+    end
+
+    def move_and_click(driver = $focus_driver)
+      element = driver.find_element(self)
+      driver.action.move_to(element).click.perform
+    end
+
+    def get_element(driver = $focus_driver)
+      driver.find_element(self)
+    end
+
+    ################################
+    # Check box methods
+    ################################
+
+    def is_checked?(driver = $focus_driver)
+      self.attribute("checked") == "true"
+    end
+
+    def check(driver = $focus_driver)
+      self.click unless self.is_checked?
+    end
+
+    def uncheck(driver = $focus_driver)
+      self.click if self.is_checked?
+    end
+
+    ##############################
+    # Text box methods
+    ##############################
+
+    def clear(driver = $focus_driver)
+      driver.find_element(self).clear
+    end
+
+    def send_keys(*args)
+      $focus_driver.find_element(self).send_keys(*args)
+    end
+
+    def clear_and_send_keys(*args)
+      clear($focus_driver)
+      send_keys(*args)
+    end
+
+    def get_value(driver = $focus_driver)
+      driver.find_element(self).attribute("value")
+    end
+    
+  end
+end