ruby_raider 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1862a69fc2192fafab5d76cacff2bfa956bfdec819c04897f80d689672962655
-  data.tar.gz: 190c50a7c66fbde69c04f2c35d6756a8737cbb529e15e5227163c99f8893c06f
+  metadata.gz: a9bd00a5bda20ac8d1d05adbe7fe90223dcdfe98f670b7a919a143d76cecbbea
+  data.tar.gz: bacd7bb799e99f97b00b06176299859661da195a62c534dc388f7edc7159f948
 SHA512:
-  metadata.gz: 5acde20915a1ecfa077e30b7aebe197e207c8216e85339be9f01e7985d989450698965eae5d0019aa49f6098bdca42a5e7ecd7e3652a274410e142bcd1f942fc
-  data.tar.gz: '08a74887fa8efb62838305aedcf99240b7c234789af3f3ec1dbb098b0a59404feb2a998146234736b41a4847ad163ceea44d88b34d0f611f73b92e64395ca2ad'
+  metadata.gz: 27ffb1a238e188672c991e8cc23b67e89efbe0c6254edffdd05de8e5523e4e928fab1b403de3c258dd24e4385a7452ecd32892815604a4494ab219ddad6c1fac
+  data.tar.gz: bc11ab83b8a776d9ccc49227dece33474039e1ef00636356d6d0224697a0bca7753f6b71e0a00d555c865d5d01c5b9504a81a1f0acfeaaf31f9092bef643dbd4

data/.gitignore

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

data/lib/generators/files/automation_file_generator.rb

@@ -1,137 +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
-    def self.generate_automation_files(name, automation, framework)
-      generate_file('abstract_page.rb', "#{name}/page_objects/abstract", abstract_page(automation, framework))
-      generate_file('abstract_component.rb', "#{name}/page_objects/abstract", abstract_component(framework))
-      generate_file('login_page.rb', "#{name}/page_objects/pages", example_page(automation))
-      generate_file('header_component.rb', "#{name}/page_objects/components", example_component)
-    end
-
-    def self.example_page(automation)
-      element = automation == 'watir' ? 'browser.element' : 'driver.find_element'
-      page_file = ERB.new <<~EOF
-        require_relative '../abstract/abstract_page'
-        require_relative '../components/header_component'
-
-        class LoginPage < AbstractPage
-
-          using #{automation == 'watir' ? 'Raider::WatirHelper' : 'Raider::SeleniumHelper'}
-
-          def url(_page)
-            'index.php?rt=account/login'
-          end
-
-          # Actions
-
-          def login(username, password)
-            username_field.send_keys username
-            password_field.send_keys password
-            login_button.click_when_present
-          end
-
-          # Components
-
-          def header
-            HeaderComponent.new(#{element}(class: 'menu_text'))
-          end
-
-          private
-
-          # Elements
-
-          def username_field
-            #{element}(id: 'loginFrm_loginname')
-          end
-
-          def password_field
-            #{element}(id: 'loginFrm_password')
-          end
-
-          def login_button
-            #{element}(xpath: "//button[@title='Login']")
-          end
-        end
-      EOF
-      page_file.result(binding)
-    end
-
-    def self.abstract_page(automation, framework)
-      browser = "def browser
-    Raider::BrowserHelper.browser
-  end"
-      driver = "def driver
-    Raider::DriverHelper.driver
-  end"
-      visit = automation == 'watir' ? 'browser.goto full_url(page.first)' : 'driver.navigate.to full_url(page.first)'
-      raider = if framework == 'rspec'
-                 "require_relative '../../helpers/raider'"
-               else
-                 "require_relative '../../features/support/helpers/raider'"
-               end
-      abstract_file = ERB.new <<~EOF
-        require 'rspec'
-        #{raider}
-
-        class AbstractPage
-
-          include RSpec::Matchers
-          extend Raider::PomHelper
-
-          #{automation == 'watir' ? browser : driver}
-
-          def visit(*page)
-            #{visit}
-          end
-
-          def full_url(*page)
-            "#\{base_url}#\{url(*page)}"
-          end
-
-          def base_url
-            'https://automationteststore.com/'
-          end
-
-          def url(_page)
-            raise 'Url must be defined on child pages'
-          end
-        end
-      EOF
-      abstract_file.result(binding)
-    end
-
-    def self.example_component
-      page_file = ERB.new <<~EOF
-        require_relative '../abstract/abstract_component'
-
-        class HeaderComponent < AbstractComponent
-
-          def customer_name
-            @component.text
-          end
-        end
-      EOF
-      page_file.result(binding)
-    end
-
-    def self.abstract_component(framework)
-      raider = if framework == 'rspec'
-                 "require_relative '../../helpers/raider'"
-               else
-                 "require_relative '../../features/support/helpers/raider'"
-               end
-      abstract_file = ERB.new <<~EOF
-        #{raider}
-
-        class AbstractComponent
-
-            def initialize(component)
-              @component = component
-            end
-        end
-      EOF
-      abstract_file.result(binding)
+    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,162 +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, framework)
-      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)
-      generate_file('Gemfile', name.to_s, gemfile_template((framework)))
-    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)
-    end
+    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 self.gemfile_template(framework)
-      if framework == 'cucumber'
-        allure_cucumber = "gem 'allure-cucumber'"
-        rspec = "gem 'rspec'"
+      def generate_readme_file(name)
+        generate_file('Readme.md', name.to_s, ReadMeTemplate.new.parsed_body)
       end
 
-      gemfile = ERB.new <<~EOF
-        # frozen_string_literal: true
+      def generate_config_file(name)
+        generate_file('config.yml', "#{name}/config", ConfigTemplate.new.parsed_body)
+      end
 
-        source 'https://rubygems.org'
+      def generate_rake_file(name)
+        generate_file('Rakefile', name.to_s, ConfigTemplate.new.parsed_body)
+      end
 
-        gem 'activesupport'
-        gem 'allure-rspec'
-        gem 'allure-ruby-commons'
-        #{allure_cucumber}
-        gem 'parallel_split_test'
-        gem 'parallel_tests'
-        gem 'rake'
-        gem '#{framework}'
-        #{rspec}
-        gem 'selenium-webdriver'
-        gem 'watir'
-        gem 'webdrivers'
-      EOF
-      gemfile.result(binding)
+      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

@@ -1,81 +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
-    def self.generate_cucumber_files(name, automation)
-      CommonFileGenerator.generate_common_files(name, 'cucumber')
-      HelpersFileGenerator.generate_helper_files(name, automation, 'cucumber')
-      generate_file('login.feature', "#{name}/features", example_feature)
-      generate_file('login_steps.rb', "#{name}/features/step_definitions", example_steps)
-      generate_file('env.rb', "#{name}/features/support", env(automation))
-      AutomationFileGenerator.generate_automation_files(name, automation, 'framework')
-    end
-
-    def self.example_feature
-      gemfile = ERB.new <<~EOF
-        Feature: Login Page
-
-        Scenario: A user can login
-          Given I'm a registered user on the login page
-          When I login with my credentials
-          Then I can see the main page
-
-      EOF
-      gemfile.result(binding)
-    end
-
-    def self.example_steps
-      gemfile = ERB.new <<~EOF
-        require_relative '../../page_objects/pages/login_page'
-
-        Given("I'm a registered user on the login page") do
-          LoginPage.visit
-        end
-
-        When('I login with my credentials') do
-          LoginPage.login('aguspe', '12341234')
-        end
-
-        When('I can see the main page') do
-          expect(LoginPage.header.customer_name).to eq 'Welcome back Agustin'
-        end
-      EOF
-      gemfile.result(binding)
-    end
-
-    def self.env(automation)
-      if automation == 'watir'
-        helper = 'helpers/browser_helper'
-        browser = 'Raider::BrowserHelper.new_browser'
-        get_browser = 'browser = Raider::BrowserHelper.new_browser'
-        screenshot = 'browser.screenshot.save("allure-results/screenshots/#{scenario.name}.png")'
-        quit = 'browser.quit'
-      else
-        helper = 'helpers/driver_helper'
-        browser = 'Raider::DriverHelper.new_driver'
-        get_browser = 'driver = Raider::DriverHelper.driver'
-        screenshot = 'driver.save_screenshot("allure-results/screenshots/#{scenario.name}.png")'
-        quit = 'driver.quit'
+    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
 
-      gemfile = ERB.new <<~EOF
-        require 'active_support/all'
-        require_relative 'helpers/allure_helper'
-        require_relative '#{helper}'
+      def generate_example_feature(name)
+        generate_file('login.feature', "#{name}/features", ExampleFeatureTemplate.new.parsed_body)
+      end
 
-        Before do
-            Raider::AllureHelper.configure
-            #{browser}
-        end
+      def generate_example_steps(name)
+        generate_file('login_steps.rb', "#{name}/features/step_definitions",
+                      ExampleStepsTemplate.new.parsed_body)
+      end
 
-        After do |scenario|
-         #{get_browser}
-          #{screenshot}
-          Raider::AllureHelper.add_screenshot(scenario.name)
-          #{quit}
-        end
-      EOF
-      gemfile.result(binding)
+      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