teber-library 0.1.1

data/README.md

@@ -0,0 +1,59 @@
+# Teber
+
+Teber Library gem is to have all the common methods that will be used in functional UI automation. 
+
+[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](LICENSE)
+[![Made with Ruby](https://img.shields.io/badge/Made%20with-Ruby-red.svg)](https://www.ruby-lang.org/en/)
+[![Published Gem](https://img.shields.io/badge/gem-teber-library-red.svg)](https://rubygems.org/gems/teber-library)
+[![StackOverflow](http://img.shields.io/badge/Stack%20Overflow-Ask-blue.svg)]( https://stackoverflow.com/users/10505289/naresh-sekar )
+[![Contributions Welcome](https://img.shields.io/badge/Contributions-Welcome-brightgreen.svg)](CONTRIBUTING.md)
+[![email me](https://img.shields.io/badge/Contact-Email-green.svg)](nareshnavinash@gmail.com)
+
+
+![alt text](lib/teber/Teber-Library-Gem.png)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'teber-library'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install teber-library
+
+## Usage
+
+This gem is to replace the library methods in [Teber-Ruby](https://github.com/nareshnavinash/Teber-Ruby) framework. This allows us to share the methods among different teams and completely ignore the repetitive work. For more details on Page object model for functional UI automation verify [Teber Ruby Documentation](https://nareshnavinash.github.io/Teber-Ruby/) page.
+
+### Adding new methods
+
+Add all the new methods inside /lib/teber/ path with the module name as 'Teber'. If added a new file, include the newly added file to the /lib/teber/teber.rb so that those methods will be available when we use the gem.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/nareshnavinash/Teber-Gem/. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## Authors
+
+* **[Naresh Sekar](https://github.com/nareshnavinash)**
+
+## License
+
+The gem is available as open source under the terms of the [GPL-3.0 License](https://opensource.org/licenses/GPL-3.0).
+
+## Code of Conduct
+
+Everyone interacting in the Teber project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/nareshnavinash/Teber-Gem/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "teber"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/teber.rb

@@ -0,0 +1,9 @@
+require "teber/version"
+require "teber/driver"
+require "teber/wait"
+require "teber/locator"
+
+module Teber
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/lib/teber/driver.rb

@@ -0,0 +1,301 @@
+module Teber
+    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"])
+          begin
+            start(driver_name,browser)
+            puts "#{driver_name} is initialized"
+          rescue Exception => e
+            puts "#{driver_name} is failed to initialize \n\n #{e.backtrace}\n\nRetrying to initialize #{driver_name}"
+            start(driver_name,browser)
+            puts "#{driver_name} is initialized after an exception"
+          end
+        end
+    
+        ##############################
+        # Custom methods of driver #
+        ##############################
+    
+        def start(driver_name, browser)
+  
+          case browser
+    
+          when 'chrome'
+            options = Selenium::WebDriver::Chrome::Options.new
+            if ENV['MODE'] == "headless" or $conf["mode"] == "headless"
+              switches = ["disable-infobars", "disable-gpu", "disable-dev-shm-usage", "no-sandbox", "headless"]
+            else
+              switches = ["disable-infobars", "disable-gpu", "disable-dev-shm-usage", "no-sandbox"]
+            end
+            switches.map { |k| options.add_argument(k) }
+            @driver = Selenium::WebDriver.for(:chrome, options: options)
+            @driver.manage.timeouts.implicit_wait = $conf["implicit_wait"]
+    
+          when 'firefox', 'ff'
+              # to be added
+  
+          when 'ie', 'internet_explorer'
+              # to be added
+  
+          when 'edge'
+              # to be added 
+  
+          when 'safari'
+              # to be added
+    
+          else
+            raise ArgumentError, "Specify a proper browser while initiating a driver \n \n#{browser.inspect}"
+          end
+    
+          target_size = Selenium::WebDriver::Dimension.new(1200, 700)
+          @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 add_to_allure_env(params)
+          location =  File.join("#{Pathname.pwd}","reports/allure/environment.properties")
+          file = File.open(location,"a")
+          file.puts "#{params}\n"
+        end
+    
+        def self.direct_add_to_allure_env(params)
+          location =  File.join("#{Pathname.pwd}","reports/allure/environment.properties")
+          file = File.open(location,"a")
+          file.puts "#{params}\n"
+        end
+    
+        def get(url)
+          $focus_driver = self
+          @driver.get(url)
+          add_to_allure_env("URL = #{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
+          TestBdd::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, *args)
+          $focus_driver = self
+          @driver.execute_script(script, *args)
+        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 self.get_current_driver
+          return $focus_driver
+        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
+  
+      end
+end

data/lib/teber/locator.rb

@@ -0,0 +1,200 @@
+module Teber
+    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 self.mouse_over(element, driver = $focus_driver)
+          driver.action.move_to(element).perform
+        end
+    
+        def click(driver = $focus_driver)
+          begin
+            driver.find_element(self).click
+            puts "Clicked - #{self.how} => #{self.what}"
+          rescue Exception => e
+            puts "Not clicked at - #{self.how} => #{self.what}"
+            puts e.message
+          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 count(driver = $focus_driver)
+          element_list = driver.find_elements(self)
+          return element_list.count
+        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_not_present?(driver = $focus_driver)
+          return !is_present?(driver)
+        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