howitzer 2.2.0 → 2.3.0

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

data/spec/support/shared_examples/meta_highlight_xpath.rb

@@ -1,41 +0,0 @@
-RSpec.shared_examples :meta_highlight_xpath do
-  let(:element) { described_class.new(name, context) }
-  describe '#xpath' do
-    let(:capybara_element) { double }
-    context 'when element is found' do
-      before { allow(element).to receive(:capybara_element) { capybara_element } }
-      it do
-        expect(capybara_element).to receive(:path)
-        element.xpath
-      end
-    end
-    context 'when element is blank' do
-      before { allow(element).to receive(:capybara_element) {} }
-      it do
-        expect(capybara_element).not_to receive(:path)
-        element.xpath
-      end
-    end
-  end
-
-  describe '#highlight' do
-    context 'when xpath blank' do
-      before { allow(element).to receive(:xpath) { nil } }
-      it do
-        expect(Howitzer::Log).to receive(:debug).with("Element #{name} not found on the page")
-        expect(context).not_to receive(:execute_script)
-        element.highlight
-      end
-    end
-    context 'when xpath is present' do
-      before { allow(element).to receive(:xpath) { '//a' } }
-      it do
-        expect(context).to receive(:execute_script).with(
-          "document.evaluate('//a', document, null, XPathResult.FIRST_ORDERED_NODE_TYPE,"\
-                             ' null).singleNodeValue.style.border = "thick solid red"'
-        )
-        element.highlight
-      end
-    end
-  end
-end

data/spec/unit/generators/base_generator_spec.rb

@@ -1,283 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Howitzer::BaseGenerator do
-  let(:output) { StringIO.new }
-  let(:destination) { Dir.mktmpdir }
-
-  describe '.logger' do
-    subject { described_class.logger }
-    before { described_class.instance_variable_set('@logger', output) }
-    it { is_expected.to eq(output) }
-  end
-
-  describe '.logger=' do
-    subject { described_class.instance_variable_get('@logger') }
-    before { described_class.logger = output }
-    it { is_expected.to eq(output) }
-  end
-
-  describe '.destination' do
-    subject { described_class.destination }
-    before { described_class.instance_variable_set('@destination', destination) }
-    it { is_expected.to eq(destination) }
-  end
-
-  describe '.destination=' do
-    subject { described_class.instance_variable_get('@destination') }
-    before { described_class.destination = destination }
-    it { is_expected.to eq(destination) }
-  end
-
-  describe 'constructor' do
-    let(:list1) { double(:list1) }
-    let(:list2) { double(:list2) }
-    let(:options) { { r: true, rspec: true } }
-    subject { described_class.new(options) }
-    before do
-      expect_any_instance_of(described_class).to receive(:print_banner).with(no_args).once
-      allow_any_instance_of(described_class).to receive(:manifest) do
-        {
-          files: list1,
-          templates: list2,
-          unknown: nil
-        }
-      end
-    end
-    it do
-      expect_any_instance_of(described_class).to receive(:copy_files).with(list1).once
-      expect_any_instance_of(described_class).to receive(:copy_templates).with(list2).once
-      expect(subject.instance_variable_get(:@options)).to eql options
-    end
-  end
-
-  describe '#manifest' do
-    subject { described_class.new({}).manifest }
-    before { allow_any_instance_of(described_class).to receive(:print_banner) { nil } }
-    it { is_expected.to eq([]) }
-  end
-
-  describe '#banner' do
-    subject { described_class.new({}).send(:banner) }
-    before { allow_any_instance_of(described_class).to receive(:print_banner) { nil } }
-    it { is_expected.to be_nil }
-  end
-
-  describe '#logger' do
-    subject { described_class.new({}).send(:logger) }
-    before { allow_any_instance_of(described_class).to receive(:print_banner) { nil } }
-    context 'when not specified' do
-      before { described_class.instance_variable_set('@logger', nil) }
-      it { is_expected.to eq($stdout) }
-    end
-    context 'when custom' do
-      let(:output) { StringIO.new }
-      before { described_class.instance_variable_set('@logger', output) }
-      it { is_expected.to eq(output) }
-    end
-  end
-
-  describe '#destination' do
-    subject { described_class.new({}).send(:destination) }
-    before do
-      allow_any_instance_of(described_class).to receive(:print_banner) { nil }
-      allow(described_class).to receive(:destination) { '/' }
-    end
-    it { is_expected.to eq('/') }
-  end
-
-  describe '#copy_files' do
-    let(:list) { [{ source: 'example.txt' }] }
-    let(:source_path) { '/example_path/example.txt' }
-    let(:generator) { described_class.new({}) }
-    subject { generator.send(:copy_files, list) }
-    before do
-      allow_any_instance_of(described_class).to receive(:print_banner) { nil }
-      allow(generator).to receive(:source_path).with(list.first[:source]) { source_path }
-    end
-    after { subject }
-    context 'when source_file exists' do
-      before { allow(File).to receive(:exist?).with(source_path) { true } }
-      it { expect(generator).to receive(:copy_with_path).with(list.first).once }
-    end
-    context 'when source_file missing' do
-      before { allow(File).to receive(:exist?).with(source_path) { false } }
-      it { expect(generator).to receive(:puts_error).with("File '/example_path/example.txt' was not found.").once }
-    end
-  end
-
-  describe '#copy_templates' do
-    let(:list) { [{ source: 'example.txt.erb', destination: 'example.txt' }] }
-    let(:source_path) { '/example_path/example.txt.erb' }
-    let(:destination_path) { '/example_path/example.txt' }
-    let(:generator) { described_class.new('rspec' => true) }
-    subject { generator.send(:copy_templates, list) }
-    before do
-      allow_any_instance_of(described_class).to receive(:print_banner) { nil }
-      allow(generator).to receive(:source_path).with(list.first[:source]) { source_path }
-      allow(generator).to receive(:dest_path).with(list.first[:destination]) { destination_path }
-      allow(generator).to receive(:write_template).with(destination_path, source_path)
-      allow(generator).to receive(:gets) { 'h' }
-    end
-    after { subject }
-    context 'when destination file exists' do
-      before { allow(File).to receive(:exist?).with(destination_path) { true } }
-      it do
-        expect(generator).to receive(:puts_info).with(
-          ColorizedString.new("Conflict with '#{list.first[:destination]}' template").yellow
-        ).once
-      end
-      it do
-        expect(generator).to receive(:print_info).with(
-          ColorizedString.new("  Overwrite '#{list.first[:destination]}' template? [Yn]:").yellow
-        ).once
-      end
-      context 'and answer is yes' do
-        before { allow(generator).to receive(:gets) { 'y' } }
-        it { expect(generator).to receive(:write_template).with(destination_path, source_path).once }
-        it { expect(generator).to receive(:puts_info).twice }
-      end
-      context 'and answer is no' do
-        before { allow(generator).to receive(:gets) { 'n' } }
-        it { expect(generator).to receive(:puts_info).twice }
-      end
-    end
-    context 'when source file exists' do
-      before { allow(File).to receive(:exist?).with(destination_path) { false } }
-      it { expect(generator).to receive(:write_template).with(destination_path, source_path).once }
-    end
-  end
-
-  describe '#print_banner' do
-    let(:generator) { described_class.new({}) }
-    subject { generator.send(:print_banner) }
-    before do
-      allow_any_instance_of(described_class).to receive(:banner) { banner }
-    end
-    after { subject }
-    context 'when banner present' do
-      let(:banner) { 'banner' }
-      it { expect(described_class.logger).to receive(:puts).with(ColorizedString.new(banner.chomp).light_cyan).twice }
-    end
-    context 'when banner blank' do
-      let(:banner) { '' }
-      it { expect(described_class.logger).not_to receive(:puts) }
-    end
-  end
-
-  describe '#print_info' do
-    subject { described_class.new({}).send(:print_info, 'data') }
-    before { allow_any_instance_of(described_class).to receive(:print_banner) { nil } }
-    after { subject }
-    it { expect(described_class.logger).to receive(:print).with('      data') }
-  end
-
-  describe '#puts_info' do
-    subject { described_class.new({}).send(:puts_info, 'data') }
-    before { allow_any_instance_of(described_class).to receive(:print_banner) { nil } }
-    after { subject }
-    it { expect(described_class.logger).to receive(:puts).with('      data') }
-  end
-
-  describe '#puts_error' do
-    subject { described_class.new({}).send(:puts_error, 'data') }
-    before { allow_any_instance_of(described_class).to receive(:print_banner) { nil } }
-    after { subject }
-    it { expect(described_class.logger).to receive(:puts).with(ColorizedString.new('      ERROR: data').red) }
-  end
-
-  describe '#source_path' do
-    subject { described_class.new({}).send(:source_path, 'example.txt') }
-    before do
-      allow_any_instance_of(described_class).to receive(:print_banner) { nil }
-    end
-    it { is_expected.to include('/base/templates/example.txt') }
-  end
-
-  describe '#dest_path' do
-    subject { described_class.new({}).send(:dest_path, 'example.txt') }
-    before { allow_any_instance_of(described_class).to receive(:print_banner) { nil } }
-    it { is_expected.to include('/example.txt') }
-  end
-
-  describe '#copy_with_path' do
-    let(:generator) { described_class.new({}) }
-    let(:data) { { source: 's.txt', destination: 'd.txt' } }
-    let(:src) { '/path/to/s.txt' }
-    let(:dst) { '/path/to/d.txt' }
-    subject { generator.send(:copy_with_path, data) }
-    before do
-      allow_any_instance_of(described_class).to receive(:print_banner) { nil }
-      allow(generator).to receive(:source_path).with('s.txt') { src }
-      allow(generator).to receive(:dest_path).with('d.txt') { dst }
-      allow(FileUtils).to receive(:mkdir_p).with('/path/to') { true }
-    end
-    after { subject }
-    context 'when destination file present' do
-      before { allow(File).to receive(:exist?).with(dst) { true } }
-      context 'when identical with source file' do
-        before { allow(FileUtils).to receive(:identical?).with(src, dst) { true } }
-        it do
-          expect(generator).to receive(:puts_info).with("#{ColorizedString.new('Identical').light_green}"\
-          " 'd.txt' file").once
-        end
-      end
-      context 'when not identical with source file' do
-        before do
-          allow(FileUtils).to receive(:identical?).with(src, dst) { false }
-          expect(generator).to receive(:puts_info).with(ColorizedString.new("Conflict with 'd.txt' file").yellow)
-          expect(generator).to receive(:print_info).with(ColorizedString.new("  Overwrite 'd.txt' file? [Yn]:").yellow)
-        end
-        context 'when user typed Y' do
-          before { allow(generator).to receive(:gets) { 'Y' } }
-          it do
-            expect(FileUtils).to receive(:cp).with(src, dst) { nil }.once
-            expect(generator).to receive(:puts_info).with("    #{ColorizedString.new('Forced').light_green}"\
-            " 'd.txt' file")
-          end
-        end
-        context 'when user typed y' do
-          before { allow(generator).to receive(:gets) { 'y' } }
-          it do
-            expect(FileUtils).to receive(:cp).with(src, dst) { nil }.once
-            expect(generator).to receive(:puts_info).with("    #{ColorizedString.new('Forced').light_green}"\
-            " 'd.txt' file")
-          end
-        end
-        context 'when user typed N' do
-          before { allow(generator).to receive(:gets) { 'N' } }
-          it do
-            expect(generator).to receive(:puts_info).with("    #{ColorizedString.new('Skipped').light_black}"\
-            " 'd.txt' file")
-            expect(FileUtils).not_to receive(:cp)
-          end
-        end
-        context 'when user typed n' do
-          before { allow(generator).to receive(:gets) { 'n' } }
-          it do
-            expect(generator).to receive(:puts_info).with("    #{ColorizedString.new('Skipped').light_black}"\
-          " 'd.txt' file")
-            expect(FileUtils).not_to receive(:cp)
-          end
-        end
-        context 'when user typed hello' do
-          before { allow(generator).to receive(:gets) { 'hello' } }
-          it do
-            expect(generator).not_to receive(:puts_info)
-            expect(FileUtils).not_to receive(:cp)
-          end
-        end
-      end
-    end
-    context 'when destination file missing' do
-      before { allow(File).to receive(:exist?).with(dst) { false } }
-      it do
-        expect(generator).to receive(:puts_info).with("#{ColorizedString.new('Added').light_green} 'd.txt' file")
-        expect(FileUtils).to receive(:cp).with(src, dst).once
-      end
-    end
-    context 'when exception happened' do
-      before { allow(FileUtils).to receive(:mkdir_p).and_raise(StandardError.new('Some error')) }
-      it { expect(generator).to receive(:puts_error).with("Impossible to create 'd.txt' file. Reason: Some error") }
-    end
-  end
-end

data/spec/unit/generators/config_generator_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'Generators' do
-  let(:destination) { Howitzer::BaseGenerator.destination }
-  let(:output) { StringIO.new }
-  subject { file_tree_info(destination) }
-  before do
-    Howitzer::BaseGenerator.logger = output
-    generator_name.new({})
-  end
-  after { FileUtils.rm_r(destination) }
-
-  describe Howitzer::ConfigGenerator do
-    let(:generator_name) { described_class }
-    let(:expected_result) do
-      [
-        { name: '/config', is_directory: true },
-        { name: '/config/boot.rb', is_directory: false, size: template_file_size('config', 'boot.rb') },
-        { name: '/config/capybara.rb', is_directory: false, size: template_file_size('config', 'capybara.rb') },
-        { name: '/config/custom.yml', is_directory: false, size: template_file_size('config', 'custom.yml') },
-        { name: '/config/default.yml', is_directory: false, size: template_file_size('config', 'default.yml') },
-        { name: '/config/drivers', is_directory: true },
-        { name: '/config/drivers/appium.rb', is_directory: false, size: 723 },
-        { name: '/config/drivers/browserstack.rb', is_directory: false, size: 1018 },
-        { name: '/config/drivers/crossbrowsertesting.rb', is_directory: false, size: 1237 },
-        { name: '/config/drivers/headless_chrome.rb', is_directory: false, size: 649 },
-        { name: '/config/drivers/headless_firefox.rb', is_directory: false, size: 1059 },
-        { name: '/config/drivers/poltergeist.rb', is_directory: false, size: 362 },
-        { name: '/config/drivers/sauce.rb', is_directory: false, size: 968 },
-        { name: '/config/drivers/selenium.rb', is_directory: false, size: 1097 },
-        { name: '/config/drivers/selenium_grid.rb', is_directory: false, size: 1377 },
-        { name: '/config/drivers/testingbot.rb', is_directory: false, size: 906 },
-        { name: '/config/drivers/webkit.rb', is_directory: false, size: 179 }
-      ]
-    end
-
-    it { is_expected.to eql(expected_result) }
-    describe 'output' do
-      let(:expected_output) do
-        "#{ColorizedString.new('  * Config files generation ...').light_cyan}
-      #{ColorizedString.new('Added').light_green} 'config/boot.rb' file
-      #{ColorizedString.new('Added').light_green} 'config/custom.yml' file
-      #{ColorizedString.new('Added').light_green} 'config/capybara.rb' file
-      #{ColorizedString.new('Added').light_green} 'config/default.yml' file
-      #{ColorizedString.new('Added').light_green} 'config/drivers/appium.rb' file
-      #{ColorizedString.new('Added').light_green} 'config/drivers/browserstack.rb' file
-      #{ColorizedString.new('Added').light_green} 'config/drivers/crossbrowsertesting.rb' file
-      #{ColorizedString.new('Added').light_green} 'config/drivers/headless_chrome.rb' file
-      #{ColorizedString.new('Added').light_green} 'config/drivers/headless_firefox.rb' file
-      #{ColorizedString.new('Added').light_green} 'config/drivers/poltergeist.rb' file
-      #{ColorizedString.new('Added').light_green} 'config/drivers/sauce.rb' file
-      #{ColorizedString.new('Added').light_green} 'config/drivers/selenium.rb' file
-      #{ColorizedString.new('Added').light_green} 'config/drivers/selenium_grid.rb' file
-      #{ColorizedString.new('Added').light_green} 'config/drivers/testingbot.rb' file
-      #{ColorizedString.new('Added').light_green} 'config/drivers/webkit.rb' file\n"
-      end
-      subject { output.string }
-      it { is_expected.to eql(expected_output) }
-    end
-  end
-end