ruby_raider 0.1.2 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b0c6d3fae74a6d921b96f3aeb216fef51378824aa78a24cbb5f9bb8a2f7c22e
-  data.tar.gz: 274ef6e35550c02473a6e6d6ffee85ca88f3a9279e379241da6b0177c7c1210e
+  metadata.gz: a9bd00a5bda20ac8d1d05adbe7fe90223dcdfe98f670b7a919a143d76cecbbea
+  data.tar.gz: bacd7bb799e99f97b00b06176299859661da195a62c534dc388f7edc7159f948
 SHA512:
-  metadata.gz: 0bc058b73aff5b99a92a06220c5d6f84e3314fca9eb99cb8a02f983308f755de245c751133fc9f9357bad8836c7cf575e0dddfd9ee83c2231e2ed5934ad71dc2
-  data.tar.gz: 5d45ba62bde3a8e3f317ec0392d3b7448b2b2ae56896f6d143916dcee9b4b37847b7fcc3e5e5dee2f1dcd8e1a735812744bc7c18943c08c4a130bffe0f653686
+  metadata.gz: 27ffb1a238e188672c991e8cc23b67e89efbe0c6254edffdd05de8e5523e4e928fab1b403de3c258dd24e4385a7452ecd32892815604a4494ab219ddad6c1fac
+  data.tar.gz: bc11ab83b8a776d9ccc49227dece33474039e1ef00636356d6d0224697a0bca7753f6b71e0a00d555c865d5d01c5b9504a81a1f0acfeaaf31f9092bef643dbd4

data/.gitignore

@@ -1,2 +1,4 @@
 ruby_raider-*.gem
-.idea/
+.idea/
+ruby_raider.iml
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -3,13 +3,18 @@ This is a gem to make setup and start of UI automation projects easier
 
 Just do:
 
-gem install ruby_raider
+**gem install ruby_raider**
 
-then do raider [name_of_project] 
+then do: 
+
+**raider [name_of_project]** 
 
 and you will have a new project in the folder you are in
 
-Currently we only support Watir with Rspec.
+Currently we only support:
+
+* Gerating a Selenium with Rspec framework
+* Gerating a Watir with Rspec framework
 
 We have only tested this in mac and linux, so it works in both platforms.
 

data/lib/generators/files/automation_file_generator.rb

@@ -0,0 +1,38 @@
+require_relative 'file_generator'
+require_relative '../templates/automation/abstract_page_template'
+require_relative '../templates/automation/abstract_component_template'
+require_relative '../templates/automation/component_template'
+require_relative '../templates/automation/page_template'
+
+module RubyRaider
+  class AutomationFileGenerator < FileGenerator
+    class << self
+      def generate_automation_files(name, automation, framework)
+        generate_example_page(automation, name)
+        generate_abstract_page(automation, framework, name)
+        generate_example_component(name)
+        generate_abstract_component(framework, name)
+      end
+
+      def generate_example_page(automation, name)
+        generate_file('login_page.rb', "#{name}/page_objects/pages",
+                      PageTemplate.new(automation: automation, name: name).parsed_body)
+      end
+
+      def generate_abstract_page(automation, framework, name)
+        generate_file('abstract_page.rb', "#{name}/page_objects/abstract",
+                      AbstractPageTemplate.new(automation: automation, framework: framework, name: name).parsed_body)
+      end
+
+      def generate_example_component(name)
+        generate_file('header_component.rb',"#{name}/page_objects/components",
+        ComponentTemplate.new.parsed_body)
+      end
+
+      def generate_abstract_component(framework, name)
+        generate_file('abstract_component.rb',"#{name}/page_objects/abstract",
+                      AbstractComponentTemplate.new(framework: framework).parsed_body)
+      end
+    end
+  end
+end

data/lib/generators/files/common_file_generator.rb

@@ -1,134 +1,34 @@
+require_relative '../templates/common/config_template'
+require_relative '../templates/common/gemfile_template'
+require_relative '../templates/common/rake_file_template'
+require_relative '../templates/common/read_me_template'
 require_relative 'file_generator'
 
 module RubyRaider
   class CommonFileGenerator < FileGenerator
-    def self.generate_common_files(name)
-      generate_file('config.yml', "#{name}/config", config_file)
-      generate_file('Rakefile', name.to_s, rake_file)
-      generate_file('Readme.md', name.to_s, readme_file)
-    end
-
-    def self.readme_file
-      rake_file = ERB.new <<~EOF
-        What is Raider?
-        ===========
-
-        Raider is a tool to make the setup and start of automation projects in ruby easier, with one command you are
-        ready to go
-
-        # Pre-requisites:
-
-        Install RVM:
-        https://rvm.io/rvm/install
-
-        # How to use the framework:
-
-        If you want to run all the tests from your terminal do:
-        *rspec spec/*
-
-        If you want to run all the tests in parallel do:
-        *parallel_rspec spec/*
-
-        # How are specs organized:
-
-        We use 'context' as the highest grouping level to indicate in which part of the application we are as an example:
-
-        *context 'On the login page'/*
-
-        We use 'describe' from the user perspective to describe an action that the user can or cannot take:
-
-        *describe 'A user can'/*
-
-        or
-
-        *describe 'A user cannot'/*
-
-        This saves us repetition and forces us into an structure
-
-        At last we use 'it' for the specific action the user can or cannot perform:
-
-        it 'login with right credentials'
-
-        If we group all of this together it will look like
-
-        ```ruby
-        context 'On the login page' do
-          describe 'A user can' do
-            it 'login with the right credentials' do
-            end
-        #{'   '}
-          end
-        #{'  '}
-          describe 'A user cannot' do
-            it 'login with the wrong credentials' do
-            end
-          end
-        end
-        ```
-        #{'    '}
-        This is readed as 'On the login page a user can login with the right credentials' and 'On the login page a user cannot login with the wrong credentials'
-
-        # How pages are organized:
-
-        ```ruby#{' '}
-        require_relative '../abstract/base_page'
-
-        class MainPage < BasePage
-
-          using Raider::WatirHelper
-
-          def url(_page)
-            '/'
-          end
-
-          # Actions
-
-          def change_currency(currency)
-            currency_dropdown.select currency
-          end
-
-          # Validations
-
-          def validate_currency(currency)
-            expect(currency_dropdown.include?(currency)).to be true
-          end
-
-          private
-
-          # Elements
-
-          def currency_dropdown
-            browser.select(class: %w[dropdown-menu currency])
-          end
-        end
-        ```
-
-        Pages are organized in Actions (things a user can perform on the page), Validations (assertions), and Elements.
-        Each page has to have a url define, and each page is using the module WatirHelper to add methods on runtime to the Watir elements
-
-      EOF
-      rake_file.result(binding)
-    end
-
-    def self.config_file
-      config_file = ERB.new <<~EOF
-        browser: :chrome
-      EOF
-      config_file.result(binding)
-    end
-
-    def self.rake_file
-      rake_file = ERB.new <<~EOF
-        require 'yaml'
-
-        desc 'Selects browser for automation run'
-        task :select_browser, [:browser] do |_t, args|
-          config = YAML.load_file('config/config.yml')
-          config['browser'] = args.browser
-          File.write('config/config.yml', config.to_yaml)
-        end
-      EOF
-      rake_file.result(binding)
+    class << self
+      def generate_common_files(name, framework)
+        generate_config_file(name)
+        generate_rake_file(name)
+        generate_readme_file(name)
+        generate_gemfile(framework, name)
+      end
+
+      def generate_readme_file(name)
+        generate_file('Readme.md', name.to_s, ReadMeTemplate.new.parsed_body)
+      end
+
+      def generate_config_file(name)
+        generate_file('config.yml', "#{name}/config", ConfigTemplate.new.parsed_body)
+      end
+
+      def generate_rake_file(name)
+        generate_file('Rakefile', name.to_s, ConfigTemplate.new.parsed_body)
+      end
+
+      def generate_gemfile(framework, name)
+        generate_file('Gemfile',name.to_s, GemfileTemplate.new(framework: framework).parsed_body)
+      end
     end
   end
 end

data/lib/generators/files/cucumber_file_generator.rb

@@ -0,0 +1,33 @@
+require_relative '../templates/cucumber/env_template'
+require_relative '../templates/cucumber/example_feature_template'
+require_relative '../templates/cucumber/example_steps_template'
+require_relative 'file_generator'
+
+module RubyRaider
+  class CucumberFileGenerator < FileGenerator
+    class << self
+      def generate_cucumber_files(name, automation)
+        AutomationFileGenerator.generate_automation_files(name, automation, 'framework')
+        CommonFileGenerator.generate_common_files(name, 'cucumber')
+        HelpersFileGenerator.generate_helper_files(name, automation, 'cucumber')
+        generate_env_file(automation, name)
+        generate_example_feature(name)
+        generate_example_steps(name)
+      end
+
+      def generate_example_feature(name)
+        generate_file('login.feature', "#{name}/features", ExampleFeatureTemplate.new.parsed_body)
+      end
+
+      def generate_example_steps(name)
+        generate_file('login_steps.rb', "#{name}/features/step_definitions",
+                      ExampleStepsTemplate.new.parsed_body)
+      end
+
+      def generate_env_file(automation, name)
+        generate_file('env.rb', "#{name}/features/support",
+                      EnvTemplate.new(automation: automation).parsed_body)
+      end
+    end
+  end
+end

data/lib/generators/files/file_generator.rb

@@ -1,9 +1,11 @@
 module RubyRaider
   class FileGenerator
-    def self.generate_file(name, path, content)
-      file_path = "#{path}/#{name}"
-      File.new(file_path, 'w+')
-      File.write(file_path, content)
+    class << self
+      def generate_file(name, path, content)
+        file_path = "#{path}/#{name}"
+        File.new(file_path, 'w+')
+        File.write(file_path, content)
+      end
     end
   end
-end
+end

data/lib/generators/files/helpers_file_generator.rb

@@ -1,234 +1,63 @@
+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)
-      generate_file('raider.rb', "#{name}/helpers", generate_raider_helper((automation)))
-      generate_file('allure_helper.rb', "#{name}/helpers", generate_allure_helper)
-      generate_file('pom_helper.rb', "#{name}/helpers", generate_pom_helper)
-      generate_file('spec_helper.rb', "#{name}/helpers", generate_spec_helper((automation)))
-      if automation == 'watir'
-        generate_file('watir_helper.rb', "#{name}/helpers", generate_watir_helper)
-        generate_file('browser_helper.rb', "#{name}/helpers", generate_browser_helper)
-      else
-        generate_file('selenium_helper.rb', "#{name}/helpers", generate_selenium_helper)
-        generate_file('driver_helper.rb', "#{name}/helpers", generate_driver_helper)
-      end
-    end
-
-    def self.generate_raider_helper(automation)
-      spec = ERB.new <<~EOF
-        module Raider
-          require_relative 'spec_helper'
-          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
-      spec = ERB.new <<~EOF
-        require 'allure-ruby-commons'
-        require 'allure-rspec'
-
-        module Raider
-          module AllureHelper
-            class << self
-
-              def configure
-                AllureRspec.configure do |config|
-                  config.results_directory = 'allure-results'
-                  config.clean_results_directory = true
-                end
-              end
-
-              def add_screenshot(name)
-                Allure.add_attachment(
-                  name: name,
-                  source: File.open("allure-results/screenshots/#{name}.png"),
-                  type: Allure::ContentType::PNG,
-                  test_case: true
-                )
-              end
-
-              def formatter
-                AllureRspecFormatter
-              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
+    class << self
+      def generate_helper_files(name, automation, 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'
+        if automation == 'watir'
+          generate_watir_helper(path)
+          generate_browser_helper(path)
+        else
+          generate_selenium_helper(path)
+          generate_driver_helper(path)
         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 ExampleDsl
-          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 hover
-              # Using actions to move the mouse over an element
-              DriverHelper.driver.action.move_to(self).perform
-            end
+      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_raider_helper(automation, framework, path)
+        generate_file('raider.rb', path,
+                      RaiderHelperTemplate.new(automation: automation, framework: framework).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_allure_helper(framework, path)
+        generate_file('allure_helper.rb', path, AllureHelperTemplate.new(framework: framework).parsed_body)
+      end
 
-      EOF
-      spec.result(binding)
-    end
+      def generate_browser_helper(path)
+        generate_file('browser_helper.rb', path, BrowserHelperTemplate.new.parsed_body)
+      end
 
-    def self.generate_driver_helper
-      spec = ERB.new <<~EOF
-        require 'selenium-webdriver'
-        require 'watir'
-        require 'webdrivers'
-        require 'yaml'
+      def generate_pom_helper(path)
+        generate_file('pom_helper.rb', path, PomHelperTemplate.new.parsed_body)
+      end
 
-        module Raider
-          module DriverHelper
-            class << self
-              attr_reader :driver
+      def generate_spec_helper(automation, path)
+        generate_file('spec_helper.rb', path, SpecHelperTemplate.new(automation: automation).parsed_body)
+      end
 
-              def new_driver
-                @driver = Selenium::WebDriver.for :chrome
-              end
-            end
-          end
-        end
+      def generate_watir_helper(path)
+        generate_file('watir_helper.rb', path, WatirHelperTemplate.new.parsed_body)
+      end
 
+      def generate_selenium_helper(path)
+        generate_file('selenium_helper.rb', path, SeleniumHelperTemplate.new.parsed_body)
+      end
 
-      EOF
-      spec.result(binding)
+      def generate_driver_helper(path)
+        generate_file('driver_helper.rb', path, DriverHelperTemplate.new.parsed_body)
+      end
     end
   end
 end

data/lib/generators/files/rspec_file_generator.rb

@@ -1,63 +1,28 @@
+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 'selenium_file_generator'
-require_relative 'watir_file_generator'
 
 module RubyRaider
   class RspecFileGenerator < FileGenerator
-    def self.generate_rspec_files(name, automation)
-      CommonFileGenerator.generate_common_files(name)
-      HelpersFileGenerator.generate_helper_files(name, automation)
-      generate_file('login_page_spec.rb', "#{name}/spec", generate_example_spec)
-      generate_file('base_spec.rb', "#{name}/spec", generate_base_spec)
-      if automation == 'watir'
-        WatirFileGenerator.generate_watir_files(name)
-      else
-        SeleniumFileGenerator.generate_selenium_files(name)
+    class << self
+      def generate_rspec_files(name, automation)
+        AutomationFileGenerator.generate_automation_files(name, automation, 'rspec')
+        CommonFileGenerator.generate_common_files(name, 'rspec')
+        HelpersFileGenerator.generate_helper_files(name, automation, 'rspec')
+        generate_base_spec(name)
+        generate_example_spec(name)
       end
-    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'
+      def generate_example_spec(name)
+        generate_file('login_page_spec.rb', "#{name}/spec", ExampleSpecTemplate.new.parsed_body)
+      end
 
-        class BaseSpec
-          include Raider::SpecHelper
-        end
-      EOF
-      spec.result(binding)
+      def generate_base_spec(name)
+        generate_file('base_spec.rb', "#{name}/spec", BaseSpecTemplate.new.parsed_body)
+      end
     end
   end
 end