howitzer 2.1.1 → 2.4.0

data/features/support/env.rb

@@ -1 +0,0 @@
-require 'aruba/cucumber'

data/generators/config/templates/drivers/phantomjs.rb

@@ -1,19 +0,0 @@
-# :phantomjs driver
-
-Capybara.register_driver :phantomjs do |app|
-  caps = {
-    javascript_enabled: !Howitzer.phantom_ignore_js_errors
-  }
-  caps['phantomjs.page.settings.userAgent'] = "WebKit #{Howitzer.user_agent}" if Howitzer.user_agent.present?
-  Capybara::Selenium::Driver.new(
-    app, browser: :phantomjs,
-         desired_capabilities: caps,
-         driver_opts: {
-           args: ["--ignore-ssl-errors=#{Howitzer.phantom_ignore_ssl_errors ? 'yes' : 'no'}"]
-         }
-  )
-end
-
-Capybara::Screenshot.class_eval do
-  register_driver :phantomjs, &registered_drivers[:selenium]
-end

data/generators/config/templates/drivers/poltergeist.rb

@@ -1,11 +0,0 @@
-# :poltergeist driver
-
-CapybaraHelpers.load_driver_gem!(:poltergeist, 'capybara/poltergeist', 'poltergeist')
-
-Capybara.register_driver :poltergeist do |app|
-  Capybara::Poltergeist::Driver.new(
-    app,
-    js_errors: !Howitzer.phantom_ignore_js_errors,
-    phantomjs_options: ["--ignore-ssl-errors=#{Howitzer.phantom_ignore_ssl_errors ? 'yes' : 'no'}"]
-  )
-end

data/generators/config/templates/drivers/webkit.rb

@@ -1,6 +0,0 @@
-# :webkit driver
-
-CapybaraHelpers.load_driver_gem!(:webkit, 'capybara-webkit', 'capybara-webkit')
-Capybara::Webkit.configure do |config|
-  config.allow_url(Howitzer.app_host)
-end

data/generators/root/templates/.gitignore

@@ -1,21 +0,0 @@
-.idea/
-custom.yml
-bin/
-log/
-eylogs/
-spec/results/
-spec/sandbox/
-tmp/
-*.swp
-*.orig
-.rakeTasks
-.bundle
-.DS_STORE
-.DS_Store
-*.xml
-*.log
-*.pem
-build-number.txt
-sauce_connect.log*
-*.*~
-capybara-*.html

data/generators/root/templates/.rubocop.yml

@@ -1,35 +0,0 @@
-# See full list of defaults here: https://github.com/bbatsov/rubocop/blob/master/config/default.yml
-# To see all cops used see here: https://github.com/bbatsov/rubocop/blob/master/config/enabled.yml
-
-AllCops:
-  TargetRubyVersion: 2.3
-  Include:
-      - Rakefile
-      - Gemfile
-
-LineLength:
-  Max: 120
-
-Layout/CaseIndentation:
-  Enabled: false
-
-Style/EmptyElse:
-  Enabled: false
-
-Lint/AmbiguousRegexpLiteral:
-  Enabled: false
-
-Lint/AmbiguousBlockAssociation:
-  Enabled: false
-
-Style/CaseEquality:
-  Enabled: false
-
-Documentation:
-  Enabled: false
-
-Style/FrozenStringLiteralComment:
-  Enabled: false
-
-Metrics/ModuleLength:
-  Max: 150

data/generators/turnip/templates/.rspec

@@ -1 +0,0 @@
--r turnip/rspec

data/howitzer.gemspec

@@ -1,39 +0,0 @@
-require File.expand_path('../lib/howitzer/version', __FILE__)
-
-Gem::Specification.new do |gem|
-  gem.author        = 'Roman Parashchenko'
-  gem.email         = 'howitzer@strongqa.com'
-  gem.description   = 'Howitzer uses the best practices and design patterns allowing to generate a test project in' \
-      ' less than 5 minutes. It has out-of-the-box configurations for parallel cross-browser testing in the cloud.'
-  gem.summary       = 'Ruby based framework for acceptance testing'
-  gem.homepage      = 'http://strongqa.github.io/howitzer/'
-  gem.license       = 'MIT'
-
-  gem.bindir        = 'bin'
-  gem.files         = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
-  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.name          = 'howitzer'
-  gem.require_paths = ['lib']
-  gem.version       = Howitzer::VERSION
-  gem.required_ruby_version = '>= 2.2.2'
-
-  gem.add_runtime_dependency 'activesupport', '~>5.0'
-  gem.add_runtime_dependency 'capybara', ['>= 2.1', '< 3.0']
-  gem.add_runtime_dependency 'colorize'
-  gem.add_runtime_dependency 'gli'
-  gem.add_runtime_dependency 'gmail'
-  gem.add_runtime_dependency 'launchy'
-  gem.add_runtime_dependency 'log4r', '~>1.1.10'
-  gem.add_runtime_dependency 'nokogiri', '~> 1.6' if gem.platform.to_s =~ /mswin|mingw/
-  gem.add_runtime_dependency 'rake'
-  gem.add_runtime_dependency 'rspec', '~>3.2'
-  gem.add_runtime_dependency 'rspec-wait'
-  gem.add_runtime_dependency 'selenium-webdriver', ['>= 3.4.1', '< 4.0']
-  gem.add_runtime_dependency 'sexy_settings'
-
-  gem.add_development_dependency('aruba')
-  gem.add_development_dependency('ffaker')
-  gem.add_development_dependency('fuubar')
-  gem.add_development_dependency('yard')
-end

data/spec/config/custom.yml

@@ -1,9 +0,0 @@
-log_dir: "spec/log"
-driver: selenium
-mailgun_domain: mailgun@test.domain
-mail_sleep_time: 0.05
-page_load_idle_timeout: 0.1
-capybara_wait_time: 5
-cloud_http_idle_timeout: 10
-hide_datetime_from_log: true
-maximized_window: false

data/spec/spec_helper.rb

@@ -1,73 +0,0 @@
-require 'rubygems'
-require 'bundler/setup'
-require 'simplecov'
-require 'coveralls'
-Coveralls.wear!
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(
-  [
-    SimpleCov::Formatter::HTMLFormatter,
-    Coveralls::SimpleCov::Formatter
-  ]
-)
-
-SimpleCov.start do
-  add_filter '/spec/'
-  add_filter '/config/'
-  add_filter do |source_file|
-    source_file.lines.count < 5
-  end
-  add_group 'generators', '/generators'
-  add_group 'lib', '/lib'
-end
-
-require 'tmpdir'
-require 'ffaker'
-require 'capybara'
-require 'json'
-require 'capybara/dsl'
-require 'active_support'
-require 'active_support/deprecation'
-require 'active_support/deprecation/method_wrappers'
-require 'active_support/core_ext'
-require 'repeater'
-require 'sexy_settings'
-require 'fake_web'
-
-SexySettings.configure do |config|
-  config.path_to_default_settings = File.expand_path(
-    'default.yml',
-    File.join(__dir__, '..', 'generators', 'config', 'templates')
-  )
-  config.path_to_custom_settings = File.expand_path(
-    'custom.yml',
-    File.join(__dir__, 'config')
-  )
-end
-
-puts SexySettings::Base.instance.as_formatted_text
-
-require 'howitzer'
-require 'howitzer/exceptions'
-
-def project_path
-  File.expand_path(File.join(__dir__, '..'))
-end
-
-def lib_path
-  File.join(project_path, 'lib')
-end
-
-def generators_path
-  File.join(project_path, 'generators')
-end
-
-def log_path
-  File.join(project_path, 'spec/log')
-end
-
-Dir[File.join(__dir__, 'support', '**', '*.rb')].each { |f| require f }
-
-RSpec.configure do |config|
-  config.include Howitzer::GeneratorHelper
-  config.disable_monkey_patching!
-end

data/spec/support/generator_helper.rb

@@ -1,21 +0,0 @@
-require 'fileutils'
-require_relative '../../generators/base_generator'
-
-module Howitzer
-  module GeneratorHelper
-    def file_tree_info(root)
-      Dir["#{root}/**/.*", "#{root}/**/*"].sort_by { |name| name.sub(root, '') }.map do |name|
-        hash = { name: name.sub(root, ''), is_directory: File.directory?(name) }
-        hash[:size] = File.stat(name).size unless hash[:is_directory]
-        hash
-      end
-    end
-
-    def template_file_size(root_directory, file)
-      File.size(File.join(generators_path, root_directory, 'templates', file))
-    end
-  end
-end
-Howitzer::BaseGenerator.logger = StringIO.new
-Howitzer::BaseGenerator.destination = Dir.mktmpdir
-Dir[File.join(generators_path, '**', '*_generator.rb')].each { |f| require f }

data/spec/support/logger_helper.rb

@@ -1,13 +0,0 @@
-module Howitzer
-  module LoggerHelper
-    def read_file(file)
-      path = File.expand_path(file, __FILE__)
-      IO.read(path)
-    end
-
-    def clear_file(file)
-      path = File.expand_path(file, __FILE__)
-      File.open(path, 'w') {}
-    end
-  end
-end

data/spec/support/shared_examples/capybara_context_holder.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-RSpec.shared_examples :capybara_context_holder do
-  describe '#capybara_context' do
-    let(:web_page_class) do
-      klass = described_class
-      Class.new do
-        include klass
-      end
-    end
-    subject { web_page_class.new.capybara_context }
-    context 'when parent class has the method' do
-      before do
-        web_page_class.class_eval do
-          def capybara_scopes
-            @_scopes ||= [true]
-          end
-        end
-      end
-      it 'should execute parent method' do
-        is_expected.to eq(true)
-      end
-    end
-    context 'when parent class does not have the method' do
-      it 'should raise error' do
-        expect { subject }.to raise_error(
-          NotImplementedError,
-          "Please define 'capybara_scopes' method for class holder"
-        )
-      end
-    end
-  end
-end

data/spec/support/shared_examples/capybara_methods_proxy.rb

@@ -1,94 +0,0 @@
-require 'spec_helper'
-
-RSpec.shared_examples :capybara_methods_proxy do
-  let(:session) { double(:session) }
-  before do
-    allow(Capybara).to receive(:current_session) { session }
-    allow(Howitzer).to receive(:driver) { driver_name }
-    allow(session).to receive(:current_url) { 'google.com' }
-  end
-
-  describe '#driver' do
-    it 'should proxy #driver method' do
-      expect(session).to receive(:driver).once
-      reciever.driver
-    end
-  end
-
-  describe '#text' do
-    it 'should proxy #text method' do
-      expect(session).to receive(:text).once
-      reciever.text
-    end
-  end
-
-  context 'when capybara session method' do
-    it 'should proxy method' do
-      expect(session).to receive(:visit).once
-      reciever.visit
-    end
-  end
-
-  context 'when capybara modal method' do
-    it 'should proxy method' do
-      expect(session).to receive(:dismiss_prompt).with(:some_text).once
-      reciever.dismiss_prompt(:some_text)
-    end
-  end
-
-  describe '#click_alert_box' do
-    subject { reciever.click_alert_box(flag_value) }
-    context 'when flag true and correct driver specified' do
-      let(:flag_value) { true }
-      let(:page) { double }
-      let(:alert) { double }
-      let(:driver) { double }
-      let(:browser) { double }
-      let(:switch_to) { double }
-      let(:driver_name) { 'selenium' }
-      it do
-        expect(session).to receive(:driver).ordered.and_return(driver)
-        expect(driver).to receive(:browser).ordered.and_return(browser)
-        expect(browser).to receive(:switch_to).ordered.and_return(switch_to)
-        expect(switch_to).to receive(:alert).ordered.and_return(alert)
-        expect(alert).to receive(:accept).once
-        subject
-      end
-    end
-    context 'when flag false and correct driver specified' do
-      let(:flag_value) { false }
-      let(:page) { double }
-      let(:alert) { double }
-      let(:driver) { double }
-      let(:browser) { double }
-      let(:switch_to) { double }
-      let(:driver_name) { 'selenium' }
-      it do
-        expect(session).to receive(:driver).ordered.and_return(driver)
-        expect(driver).to receive(:browser).ordered.and_return(browser)
-        expect(browser).to receive(:switch_to).ordered.and_return(switch_to)
-        expect(switch_to).to receive(:alert).ordered.and_return(alert)
-        expect(alert).to receive(:dismiss).once
-        subject
-      end
-    end
-    context 'when flag true and wrong driver specified' do
-      let(:flag_value) { true }
-      let(:page) { double }
-      let(:driver_name) { 'ff' }
-      it do
-        expect(session).to receive(:evaluate_script).with('window.confirm = function() { return true; }')
-        subject
-      end
-    end
-    context 'when flag false and wrong driver specified' do
-      let(:driver_name) { 'ff' }
-      let(:flag_value) { false }
-      let(:page) { double }
-      it do
-        expect(session).to receive(:evaluate_script).with('window.confirm = function() { return false; }')
-        subject
-      end
-    end
-  end
-end

data/spec/support/shared_examples/dynamic_section_methods.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-RSpec.shared_examples :dynamic_section_methods do
-  let(:web_page_object) { web_page_class.new }
-
-  describe '#name_section' do
-    let(:capybara_element) { double }
-    subject { web_page_object.send("#{section_name}_section") }
-    before { expect(session).to receive(:find).with(*finder_args).once.and_return(capybara_element) }
-    it { is_expected.to be_a(section_class) }
-  end
-  describe '#name_sections' do
-    subject { web_page_object.send("#{section_name}_sections") }
-    let(:capybara_element1) { double }
-    let(:capybara_element2) { double }
-    before do
-      expect(session).to receive(:all).with(*finder_args).once.and_return([capybara_element1, capybara_element2])
-    end
-    it 'should return collection of sections' do
-      res = subject
-      expect(res.size).to eq(2)
-      expect(res.first).to be_a(section_class)
-      expect(res.last).to be_a(section_class)
-    end
-  end
-  describe '#has_name_section?' do
-    subject { web_page_object.send("has_#{section_name}_section?") }
-    before { expect(session).to receive(:has_selector?).with(*finder_args).once.and_return(true) }
-    it { is_expected.to eq(true) }
-  end
-  describe '#has_no_name_element?' do
-    subject { web_page_object.send("has_no_#{section_name}_section?") }
-    before { expect(session).to receive(:has_no_selector?).with(*finder_args).once.and_return(true) }
-    it { is_expected.to eq(true) }
-  end
-end

data/spec/support/shared_examples/element_dsl.rb

@@ -1,242 +0,0 @@
-require 'spec_helper'
-
-RSpec.shared_examples :element_dsl do
-  describe '.element' do
-    context 'when regular capybara params' do
-      before do
-        klass.class_eval do
-          element :foo, :xpath, '//a'
-        end
-      end
-      it 'should create private :foo_element instance method' do
-        expect(klass_object.private_methods(false)).to include(:foo_element)
-      end
-      it 'should create private :foo_elements instance method' do
-        expect(klass_object.private_methods(false)).to include(:foo_elements)
-      end
-      it 'should create private :wait_for_foo_element instance method' do
-        expect(klass_object.private_methods(false)).to include(:wait_for_foo_element)
-      end
-      it 'should create public :has_foo_element? instance method' do
-        expect(klass_object.public_methods(false)).to include(:has_foo_element?)
-      end
-      it 'should create public :has_no_foo_element? instance method' do
-        expect(klass_object.public_methods(false)).to include(:has_no_foo_element?)
-      end
-      it 'should be protected class method' do
-        expect { klass.element :bar }.to raise_error(NoMethodError)
-        expect(klass.protected_methods(true)).to include(:element)
-      end
-    end
-    context 'when 1 param is proc' do
-      before do
-        klass.class_eval do
-          element :foo, :xpath, ->(title) { "//a[.='#{title}']" }
-        end
-      end
-      it 'should create private :foo_element instance method' do
-        expect(klass_object.private_methods(false)).to include(:foo_element)
-      end
-      it 'should create private :foo_elements instance method' do
-        expect(klass_object.private_methods(false)).to include(:foo_elements)
-      end
-      it 'should create private :wait_for_foo_element instance method' do
-        expect(klass_object.private_methods(false)).to include(:wait_for_foo_element)
-      end
-      it 'should create public :has_foo_element? instance method' do
-        expect(klass_object.public_methods(false)).to include(:has_foo_element?)
-      end
-      it 'should create public :has_no_foo_element? instance method' do
-        expect(klass_object.public_methods(false)).to include(:has_no_foo_element?)
-      end
-      it 'should be protected class method' do
-        expect { klass.element :bar }.to raise_error(NoMethodError)
-        expect(klass.protected_methods(true)).to include(:element)
-      end
-    end
-    context 'when 2 params are proc' do
-      subject do
-        klass.class_eval do
-          element :foo, -> { puts 1 }, ->(title) { "//a[.='#{title}']" }
-        end
-      end
-      it 'should generate error' do
-        expect { subject.element :bar }.to raise_error(
-          Howitzer::BadElementParamsError,
-          'Using more than 1 proc in arguments is forbidden'
-        )
-      end
-    end
-  end
-
-  describe 'dynamic_methods' do
-    let(:web_page_object) { web_page_class.new }
-    let(:kontext) { double(:kontext) }
-    before do
-      allow(Capybara).to receive(:current_session) { kontext }
-      klass.class_eval do
-        element :foo, :xpath,
-                ->(title, name) { "//a[.='#{title}']/*[@name='#{name}']" }, text: 'original', match: :first
-        element :bar, '.someclass', text: 'origin', match: :first
-        element :top_panel, '.top', text: 'origin', match: :first
-      end
-    end
-
-    describe '#name_element' do
-      context 'when simple selector' do
-        subject { klass_object.send(:bar_element, text: 'new', wait: 10) }
-        after { subject }
-        it do
-          expect(klass_object.capybara_context).to receive(:find)
-            .with('.someclass', wait: 10, text: 'new', match: :first)
-        end
-      end
-      context 'when lambda selector' do
-        subject { klass_object.send(:foo_element, 'Hello', 'super', text: 'new', wait: 10) }
-        after { subject }
-        it do
-          expect(klass_object.capybara_context).to receive(:find)
-            .with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first)
-        end
-
-        context 'when several execution with different data' do
-          it 'does not cache previous data' do
-            expect(klass_object.capybara_context).to receive(:find)
-              .with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first).at_least(:once)
-            klass_object.send(:foo_element, 'Hello', 'super', text: 'new', wait: 10)
-
-            expect(klass_object.capybara_context).to receive(:find)
-              .with(:xpath, "//a[.='Bye']/*[@name='puper']", wait: 15, text: 'new', match: :first).at_least(:once)
-            klass_object.send(:foo_element, 'Bye', 'puper', text: 'new', wait: 15)
-          end
-        end
-      end
-    end
-    describe '#name_elements' do
-      after { subject }
-      context 'when simple selector' do
-        subject { klass_object.send(:bar_elements, text: 'new', wait: 10) }
-        it do
-          expect(klass_object.capybara_context).to receive(:all)
-            .with('.someclass', wait: 10, text: 'new', match: :first)
-        end
-      end
-      context 'when lambda selector' do
-        subject { klass_object.send(:foo_elements, 'Hello', 'super', text: 'new', wait: 10) }
-        it do
-          expect(
-            klass_object.capybara_context
-          ).to receive(:all).with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first)
-        end
-      end
-    end
-    describe '#wait_for_name_element' do
-      context 'when simple selector' do
-        subject { klass_object.send(:wait_for_bar_element, text: 'new', wait: 10) }
-        it do
-          expect(klass_object.capybara_context).to receive(:find)
-            .with('.someclass', wait: 10, text: 'new', match: :first)
-          is_expected.to eq(nil)
-        end
-      end
-      context 'when lambda selector' do
-        subject { klass_object.send(:wait_for_foo_element, 'Hello', 'super', text: 'new', wait: 10) }
-        it do
-          expect(
-            klass_object.capybara_context
-          ).to receive(:find).with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first)
-          is_expected.to eq(nil)
-        end
-      end
-    end
-    describe '#within_name_element' do
-      let(:within_scope) { double }
-      after { subject }
-      context 'not nested' do
-        context 'when simple selector' do
-          subject do
-            klass_object.instance_eval do
-              within_bar_element(wait: 5, text: 'new') do
-                foo_element('Hello', 'super', wait: 10, text: 'new')
-              end
-            end
-          end
-          it do
-            expect(klass_object.capybara_context).to receive(:find)
-              .with('.someclass', wait: 5, text: 'new', match: :first) { within_scope }
-            expect(within_scope).to receive(:find)
-              .with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first)
-          end
-        end
-        context 'when lambda selector' do
-          subject do
-            klass_object.instance_eval do
-              within_foo_element('Hello', 'super', wait: 10, text: 'new') do
-                bar_element(wait: 10, text: 'new')
-              end
-            end
-          end
-          it do
-            expect(klass_object.capybara_context).to receive(:find)
-              .with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first) { within_scope }
-            expect(within_scope).to receive(:find).with('.someclass', wait: 10, text: 'new', match: :first)
-          end
-        end
-      end
-      context 'nested' do
-        let(:nested_within_scope) { double }
-        subject do
-          klass_object.instance_eval do
-            within_top_panel_element(wait: 10, text: 'new') do
-              within_bar_element(wait: 10, text: 'new') do
-                foo_element('Hello', 'super', wait: 10, text: 'new')
-              end
-            end
-          end
-        end
-        it do
-          expect(klass_object.capybara_context).to receive(:find)
-            .with('.top', wait: 10, text: 'new', match: :first) { within_scope }
-          expect(within_scope).to receive(:find)
-            .with('.someclass', wait: 10, text: 'new', match: :first) { nested_within_scope }
-          expect(nested_within_scope).to receive(:find)
-            .with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first)
-        end
-      end
-    end
-    describe '#has_name_element?' do
-      after { subject }
-      context 'when simple selector' do
-        subject { klass_object.send(:has_bar_element?, wait: 10, text: 'new') }
-        it do
-          expect(klass_object.capybara_context).to receive(:has_selector?)
-            .with('.someclass', wait: 10, text: 'new', match: :first)
-        end
-      end
-      context 'when lambda selector' do
-        subject { klass_object.send(:has_foo_element?, 'Hello', 'super', wait: 10, text: 'new') }
-        it do
-          expect(klass_object.capybara_context).to receive(:has_selector?)
-            .with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first)
-        end
-      end
-    end
-    describe '#has_no_name_element?' do
-      after { subject }
-      context 'when simple selector' do
-        subject { klass_object.send(:has_no_bar_element?, wait: 10, text: 'new') }
-        it do
-          expect(klass_object.capybara_context).to receive(:has_no_selector?)
-            .with('.someclass', wait: 10, text: 'new', match: :first)
-        end
-      end
-      context 'when lambda selector' do
-        subject { klass_object.send(:has_no_foo_element?, 'Hello', 'super', wait: 10, text: 'new', match: :first) }
-        it do
-          expect(klass_object.capybara_context).to receive(:has_no_selector?)
-            .with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first)
-        end
-      end
-    end
-  end
-end