ruby_raider 0.1.5 → 0.1.9

data/lib/generators/files/helpers_file_generator.rb

@@ -1,244 +1,70 @@
+require_relative '../templates/helpers/allure_helper_template'
+require_relative '../templates/helpers/browser_helper_template'
+require_relative '../templates/helpers/driver_helper_template'
+require_relative '../templates/helpers/pom_helper_template'
+require_relative '../templates/helpers/raider_helper_template'
+require_relative '../templates/helpers/spec_helper_template'
+require_relative '../templates/helpers/selenium_helper_template'
+require_relative '../templates/helpers/watir_helper_template'
 require_relative 'file_generator'
 
 module RubyRaider
   class HelpersFileGenerator < FileGenerator
-    def self.generate_helper_files(name, automation, framework)
-      path = framework == 'rspec' ? "#{name}/helpers" : "#{name}/features/support/helpers"
-      generate_file('raider.rb', path, generate_raider_helper(automation, framework))
-      generate_file('allure_helper.rb', path, generate_allure_helper(framework))
-      generate_file('pom_helper.rb', path, generate_pom_helper)
-      generate_file('spec_helper.rb', path, generate_spec_helper((automation))) if framework == 'rspec'
-      if automation == 'watir'
-        generate_file('watir_helper.rb', path, generate_watir_helper)
-        generate_file('browser_helper.rb', path, generate_browser_helper)
-      else
-        generate_file('selenium_helper.rb', path, generate_selenium_helper)
-        generate_file('driver_helper.rb', path, generate_driver_helper)
+    class << self
+      def generate_helper_files(automation, name, framework)
+        path = framework == 'rspec' ? "#{name}/helpers" : "#{name}/features/support/helpers"
+        generate_raider_helper(automation, framework, path)
+        generate_allure_helper(framework, path)
+        generate_pom_helper(path)
+        generate_spec_helper(automation, path) if framework == 'rspec'
+        select_helpers(automation, path)
       end
-    end
-
-    def self.generate_raider_helper(automation, framework)
-      spec = ERB.new <<~EOF
-        module Raider
-          #{"require_relative 'spec_helper'" if framework == 'rspec'}
-          require_relative '#{automation}_helper'
-          require_relative 'pom_helper'
-          require_relative '#{automation == 'watir' ? 'browser_helper' : 'driver_helper'}'
-          require_relative 'allure_helper'
-        end
-      EOF
 
-      spec.result(binding)
-    end
-
-    def self.generate_allure_helper(framework)
-      if framework == 'cucumber'
-        gems = "require 'allure-cucumber'"
-        allure = 'AllureCucumber'
-      else
-        gems = "require 'allure-ruby-commons'
-require 'allure-rspec'"
-        allure = 'AllureRspec'
+      def generate_raider_helper(automation, framework, path)
+        generate_file('raider.rb', path,
+                      RaiderHelperTemplate.new(automation: automation, framework: framework).parsed_body)
       end
-      spec = ERB.new <<~EOF
-        #{gems}
-
-        module Raider
-          module AllureHelper
-            class << self
-
-              def configure
-                #{allure}.configure do |config|
-                  config.results_directory = 'allure-results'
-                  config.clean_results_directory = true
-                end
-              end
-
-              def add_screenshot(screenshot_name)
-                Allure.add_attachment(
-                  name: name,
-                  source: "File.open(allure-results/screenshots/\#{screenshot_name}.png)",
-                  type: Allure::ContentType::PNG,
-                  test_case: true
-                )
-              end
-
-              #{
-        if framework == 'rspec'
-          'def formatter
-        AllureRspecFormatter
-      end'
-        end }
-            end
-          end
-        end
-      EOF
-      spec.result(binding)
-    end
-
-    def self.generate_browser_helper
-      spec = ERB.new <<~EOF
-        require 'yaml'
-        require 'selenium-webdriver'
-        require 'watir'
-        require 'webdrivers'
-
-        module Raider
-          module BrowserHelper
-            class << self
-              attr_reader :browser
-
-              def new_browser
-                config = YAML.load_file('config/config.yml')
-                @browser = Watir::Browser.new config['browser']
-              end
-            end
-          end
-        end
-
-      EOF
-      spec.result(binding)
-    end
-
-    def self.generate_pom_helper
-      spec = ERB.new <<~EOF
-        module Raider
-          module PomHelper
-            def instance
-              @instance ||= new
-            end
-
-            def method_missing(message, *args, &block)
-              return super unless instance.respond_to?(message)
-
-              instance.public_send(message, *args, &block)
-            end
-
-            def respond_to_missing?(method, *_args, &block)
-              instance.respond_to?(method) || super
-            end
-          end
-        end
-      EOF
-      spec.result(binding)
-    end
-
-    def self.generate_spec_helper(automation)
-      spec = ERB.new <<~EOF
-        require 'active_support/all'
-        require 'rspec'
-        require_relative 'allure_helper'
-        require_relative '#{automation == 'watir' ? 'browser_helper' : 'driver_helper'}'
 
-        module Raider
-          module SpecHelper
-
-            AllureHelper.configure
-
-            RSpec.configure do |config|
-              config.formatter = AllureHelper.formatter
-              config.before(:each) do
-                #{automation == 'watir' ? 'BrowserHelper.new_browser' : 'DriverHelper.new_driver'}
-              end
-
-              config.after(:each) do
-                #{automation == 'watir' ? 'browser = BrowserHelper.browser' : 'driver = DriverHelper.driver'}
-                example_name = self.class.descendant_filtered_examples.first.description
-                status = self.class.descendant_filtered_examples.first.execution_result.status
-                #{automation == 'watir' ? 'browser' : 'driver'}.save_screenshot("allure-results/screenshots/#\{example_name}.png") if status == :failed
-                AllureHelper.add_screenshot example_name if status == :failed
-                #{automation == 'watir' ? 'browser.quit' : 'driver.quit'}
-              end
-            end
-          end
-        end
-      EOF
-      spec.result(binding)
-    end
-
-    def self.generate_watir_helper
-      spec = ERB.new <<~EOF
-        require 'watir'
-
-        module Raider
-          module WatirHelper
-            refine Watir::Element do
-              def click_when_present
-                wait_until_present
-                self.click
-              end
-
-              def wait_until_present
-                self.wait_until(&:present?)
-              end
-            end
-          end
-        end
-      EOF
-      spec.result(binding)
-    end
-
-    def self.generate_selenium_helper
-      spec = ERB.new <<~EOF
-        require 'selenium-webdriver'
-        require_relative 'driver_helper'
-
-        module Raider
-          module SeleniumHelper
-            def click_when_present
-              # This is an example of an implicit wait in selenium
-              wait = Selenium::WebDriver::Wait.new(timeout: 15)
-              wait.until { present? }
-              click
-            end
-
-            def select_by(key, value)
-              # Creates new Select object to use the select by method
-              dropdown = Selenium::WebDriver::Support::Select.new self
-              dropdown.select_by(key, value)
-            end
+      def generate_allure_helper(framework, path)
+        generate_file('allure_helper.rb', path, AllureHelperTemplate.new(framework: framework).parsed_body)
+      end
 
-            def hover
-              # Using actions to move the mouse over an element
-              DriverHelper.driver.action.move_to(self).perform
-            end
+      def generate_browser_helper(path)
+        generate_file('browser_helper.rb', path, BrowserHelperTemplate.new.parsed_body)
+      end
 
-            # How to perform right click through the context click method
-            def right_click
-              DriverHelper.driver.action.context_click(self).perform
-            end
-          end
+      def generate_pom_helper(path)
+        generate_file('pom_helper.rb', path, PomHelperTemplate.new.parsed_body)
+      end
 
-          # Here we are opening the selenium class and adding our custom method
-          class Selenium::WebDriver::Element
-            include SeleniumHelper
-          end
-        end
+      def generate_spec_helper(automation, path)
+        generate_file('spec_helper.rb', path, SpecHelperTemplate.new(automation: automation).parsed_body)
+      end
 
-      EOF
-      spec.result(binding)
-    end
+      def generate_watir_helper(path)
+        generate_file('watir_helper.rb', path, WatirHelperTemplate.new.parsed_body)
+      end
 
-    def self.generate_driver_helper
-      spec = ERB.new <<~EOF
-        require 'selenium-webdriver'
-        require 'watir'
-        require 'webdrivers'
-        require 'yaml'
+      def generate_selenium_helper(path)
+        generate_file('selenium_helper.rb', path, SeleniumHelperTemplate.new.parsed_body)
+      end
 
-        module Raider
-          module DriverHelper
-            class << self
-              attr_reader :driver
+      def generate_driver_helper(automation, path)
+        generate_file('driver_helper.rb', path, DriverHelperTemplate.new(automation: automation).parsed_body)
+      end
 
-              def new_driver
-                @driver = Selenium::WebDriver.for :chrome
-              end
-            end
-          end
+      def select_helpers(automation, path)
+        case automation
+        when 'watir'
+          generate_watir_helper(path)
+          generate_browser_helper(path)
+        when 'selenium'
+          generate_selenium_helper(path)
+          generate_driver_helper(automation, path)
+        else
+          generate_driver_helper(automation, path)
         end
-      EOF
-      spec.result(binding)
+      end
     end
   end
 end

data/lib/generators/files/rspec_file_generator.rb

@@ -1,58 +1,29 @@
+require_relative '../templates/rspec/example_spec_template'
+require_relative '../templates/rspec/base_spec_template'
+require_relative 'automation_file_generator'
 require_relative 'common_file_generator'
 require_relative 'file_generator'
 require_relative 'helpers_file_generator'
-require_relative 'automation_file_generator'
 
 module RubyRaider
   class RspecFileGenerator < FileGenerator
-    def self.generate_rspec_files(name, automation)
-      CommonFileGenerator.generate_common_files(name, 'rspec')
-      HelpersFileGenerator.generate_helper_files(name, automation, 'rspec')
-      generate_file('login_page_spec.rb', "#{name}/spec", generate_example_spec)
-      generate_file('base_spec.rb', "#{name}/spec", generate_base_spec)
-      AutomationFileGenerator.generate_automation_files(name, automation, 'rspec')
-    end
-
-    def self.generate_example_spec
-      spec = ERB.new <<~EOF
-        require_relative 'base_spec'
-        require_relative '../page_objects/pages/login_page'
-
-        class LoginSpec < BaseSpec
-          context 'On the Login Page' do
-
-            before(:each) do
-              LoginPage.visit
-            end
-
-            describe 'A user can' do
-              it 'login with the right credentials', :JIRA_123 do
-                LoginPage.login('aguspe', '12341234')
-                expect(LoginPage.header.customer_name).to eq 'Welcome back Agustin'
-              end
-            end
-
-            describe 'A user cannot' do
-              it 'login with the wrong credentials', :JIRA_123 do
-                LoginPage.login('aguspe', 'wrongPassword')
-                expect(LoginPage.header.customer_name).to be_empty
-              end
-            end
-          end
-        end
-      EOF
-      spec.result(binding)
-    end
-
-    def self.generate_base_spec
-      spec = ERB.new <<~EOF
-         require_relative '../helpers/raider'
-
-        class BaseSpec
-          include Raider::SpecHelper
-        end
-      EOF
-      spec.result(binding)
+    class << self
+      def generate_rspec_files(automation, name)
+        AutomationFileGenerator.generate_automation_files(automation, name,'rspec')
+        CommonFileGenerator.generate_common_files(automation, name, 'rspec')
+        HelpersFileGenerator.generate_helper_files(automation, name, 'rspec')
+        generate_base_spec(name)
+        generate_example_spec(automation, name)
+      end
+
+      def generate_example_spec(automation, name)
+        generate_file('login_page_spec.rb', "#{name}/spec",
+                      ExampleSpecTemplate.new(automation: automation).parsed_body)
+      end
+
+      def generate_base_spec(name)
+        generate_file('base_spec.rb', "#{name}/spec", BaseSpecTemplate.new.parsed_body)
+      end
     end
   end
 end

data/lib/generators/menu_generator.rb

@@ -4,41 +4,56 @@ require_relative '../generators/projects/rspec_project_generator'
 
 module RubyRaider
   class MenuGenerator
-    def self.generate_choice_menu(project_name)
-      cli = HighLine.new
-      cli.choose do |menu|
-        menu.prompt = 'Please select your automation framework'
-        menu.choice(:Selenium) { choose_test_framework('selenium', project_name) }
-        menu.choice(:Watir) { choose_test_framework('watir', project_name) }
-        menu.choice(:Quit, 'Exit program.') { exit }
+    class << self
+      def generate_choice_menu(project_name)
+        @cli = HighLine.new
+        @cli.choose do |menu|
+          menu.prompt = 'Please select your automation framework'
+          menu.choice('Selenium') { choose_test_framework('selenium', project_name) }
+          menu.choice('Watir') { choose_test_framework('watir', project_name) }
+          menu.choice('Appium') { choose_test_framework('appium', project_name) }
+          menu.choice('Quit') { exit }
+        end
       end
-    end
 
-    def self.choose_test_framework(automation, project_name)
-      system('clear') || system('cls')
-      sleep 0.3
-      cli = HighLine.new
-      framework = ''
-      cli.choose do |menu|
-        menu.prompt = 'Please select your test framework'
-        menu.choice(:Rspec) do
-          framework = 'rspec'
-          set_framework(automation, framework, project_name)
+      def choose_test_framework(automation, project_name)
+        system('clear') || system('cls')
+        sleep 0.3
+        automation = automation == 'appium' ? choose_mobile_platform : automation
+        framework = ''
+        @cli.choose do |menu|
+          menu.prompt = 'Please select your test framework'
+          menu.choice('Rspec') { framework = 'rspec'; set_framework(automation, framework, project_name) }
+          menu.choice('Cucumber') do
+            if %w[selenium watir].include? automation
+              framework = 'cucumber'
+              set_framework(automation, framework, project_name)
+            else
+              pp 'We will support iOS with cucumber on the next release'
+              exit
+            end
+          end
+          menu.choice('Quit') { exit }
         end
-        menu.choice(:Cucumber) do
-          framework = 'cucumber'
-          set_framework(automation, framework, project_name)
+        @cli.say("You have chosen to use #{framework} with #{automation}")
+      end
+
+      def set_framework(automation, framework, project_name)
+        if framework == 'rspec'
+          RspecProjectGenerator.generate_rspec_project(automation, project_name)
+        else
+          CucumberProjectGenerator.generate_cucumber_project(automation, project_name)
         end
-        menu.choice(:Quit, 'Exit program.') { exit }
       end
-      cli.say("You have chosen to use #{framework} with #{automation}")
-    end
 
-    def self.set_framework(automation, framework, project_name)
-      if framework == 'rspec'
-        RspecProjectGenerator.generate_rspec_project(project_name, automation: automation)
-      else
-        CucumberProjectGenerator.generate_cucumber_project(project_name, automation: automation)
+      def choose_mobile_platform
+        @cli.choose do |menu|
+          menu.prompt = 'Please select your mobile platform'
+          menu.choice('iOS') { 'appium_ios' }
+          menu.choice('Android') { pp 'Android appium is coming soon. Thank you for the interest'; exit }
+          menu.choice('Cross Platform') { pp 'Cross platform appium is coming soon. Thank you for the interest'; exit }
+          menu.choice('Quit') { exit }
+        end
       end
     end
   end

data/lib/generators/projects/cucumber_project_generator.rb

@@ -3,22 +3,32 @@ require_relative 'project_generator'
 
 module RubyRaider
   class CucumberProjectGenerator < ProjectGenerator
-    def self.generate_cucumber_project(name, automation: 'watir')
-      cucumber_folder_structure(name)
-      CucumberFileGenerator.generate_cucumber_files(name, automation)
-      ProjectGenerator.install_gems(name)
-    end
+    class << self
+      def generate_cucumber_project(automation, name)
+        cucumber_folder_structure(automation, name)
+        CucumberFileGenerator.generate_cucumber_files(automation, name)
+        ProjectGenerator.install_gems(name)
+      end
+
+      def cucumber_folder_structure(automation, name)
+        create_project_folder(name)
+        create_base_folders(automation, name)
+        create_features_child_folders(name)
+        Dir.mkdir "#{name}/features/support/helpers"
+        create_po_child_folders(automation, name)
+        Dir.mkdir "#{name}/allure-results/screenshots"
+      end
+
+      def create_base_folders(automation, name)
+        folders = %w[features page_objects allure-results]
+        create_children_folders("#{name}", folders)
+        Dir.mkdir "#{name}/config" if %w[selenium watir].include?(automation)
+      end
 
-    def self.cucumber_folder_structure(name)
-      Dir.mkdir name.to_s
-      folders = %w[features config page_objects allure-results]
-      create_children_folders("#{name}", folders)
-      folders = %w[step_definitions support]
-      create_children_folders("#{name}/features", folders)
-      Dir.mkdir "#{name}/features/support/helpers"
-      folders = %w[abstract pages components]
-      create_children_folders("#{name}/page_objects", folders)
-      Dir.mkdir "#{name}/allure-results/screenshots"
+      def create_features_child_folders(name)
+        folders = %w[step_definitions support]
+        create_children_folders("#{name}/features", folders)
+      end
     end
   end
 end

data/lib/generators/projects/project_generator.rb

@@ -1,11 +1,27 @@
 module RubyRaider
   class ProjectGenerator
-    def self.create_children_folders(parent, folders)
-      folders.each { |folder| Dir.mkdir "#{parent}/#{folder}" }
-    end
+    class << self
+      def create_children_folders(parent, folders)
+        folders.each { |folder| Dir.mkdir "#{parent}/#{folder}" }
+      end
+
+      def install_gems(name)
+        system "cd #{name} && gem install bundler && bundle install"
+      end
+
+      def create_project_folder(name)
+        Dir.mkdir name.to_s
+      end
+
+      def create_base_folders
+        raise 'Please specify the base folders for the projects'
+      end
 
-    def self.install_gems(name)
-      system "cd #{name} && gem install bundler && bundle install"
+      def create_po_child_folders(automation, name)
+        folders = %w[pages abstract]
+        create_children_folders("#{name}/page_objects", folders)
+        Dir.mkdir "#{name}/page_objects/components" if %w[selenium watir].include?(automation)
+      end
     end
   end
 end

data/lib/generators/projects/rspec_project_generator.rb

@@ -3,18 +3,24 @@ require_relative '../files/rspec_file_generator'
 
 module RubyRaider
   class RspecProjectGenerator < ProjectGenerator
-    def self.generate_rspec_project(name, automation: 'watir')
-      rspec_folder_structure(name)
-      RspecFileGenerator.generate_rspec_files(name, automation)
-      ProjectGenerator.install_gems(name)
-    end
+    class << self
+      def generate_rspec_project(automation, name)
+        rspec_folder_structure(automation, name)
+        RspecFileGenerator.generate_rspec_files(automation, name)
+        ProjectGenerator.install_gems(name)
+      end
+
+      def rspec_folder_structure(automation, name)
+        create_project_folder(name)
+        create_base_folders(automation, name)
+        create_po_child_folders(automation, name)
+      end
 
-    def self.rspec_folder_structure(name)
-      Dir.mkdir name.to_s
-      folders = %w[config data page_objects helpers spec]
-      create_children_folders(name, folders)
-      pages = %w[pages components abstract]
-      create_children_folders("#{name}/page_objects", pages)
+      def create_base_folders(automation, name)
+        folders = %w[data page_objects helpers spec]
+        create_children_folders(name, folders)
+        Dir.mkdir "#{name}/config" if %w[selenium watir].include?(automation)
+      end
     end
   end
 end

data/lib/generators/templates/automation/abstract_component_template.rb

@@ -0,0 +1,22 @@
+require_relative '../template'
+
+class AbstractComponentTemplate < Template
+  def body
+    raider = if @framework == 'rspec'
+               "require_relative '../../helpers/raider'"
+             else
+               "require_relative '../../features/support/helpers/raider'"
+             end
+
+    <<~EOF
+      #{raider}
+
+      class AbstractComponent
+
+          def initialize(component)
+            @component = component
+          end
+      end
+    EOF
+  end
+end