howitzer 2.0.3 → 2.3.0

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/unit/generators/base_generator_spec.rb

@@ -1,272 +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 { expect(generator).to receive(:puts_info).with("Conflict with '#{list.first[:destination]}' template").once }
-      it do
-        expect(generator).to receive(:print_info).with(
-          "  Overwrite '#{list.first[:destination]}' template? [Yn]:"
-        ).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(banner).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('      ERROR: data') }
-  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 { expect(generator).to receive(:puts_info).with("Identical 'd.txt' file").once }
-      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("Conflict with 'd.txt' file")
-          expect(generator).to receive(:print_info).with("  Overwrite 'd.txt' file? [Yn]:")
-        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("    Forced '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("    Forced '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("    Skipped '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("    Skipped '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("Added '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,38 +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') }
-      ]
-    end
-
-    it { is_expected.to eql(expected_result) }
-    describe 'output' do
-      let(:expected_output) do
-        "  * Config files generation ...
-      Added 'config/boot.rb' file
-      Added 'config/custom.yml' file
-      Added 'config/capybara.rb' file
-      Added 'config/default.yml' file\n"
-      end
-      subject { output.string }
-      it { is_expected.to eql(expected_output) }
-    end
-  end
-end

data/spec/unit/generators/cucumber_generator_spec.rb

@@ -1,62 +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(cucumber: true)
-  end
-  after { FileUtils.rm_r(destination) }
-
-  describe Howitzer::CucumberGenerator do
-    let(:generator_name) { described_class }
-    let(:expected_result) do
-      [
-        { name: '/features', is_directory: true },
-        {
-          name: '/features/example.feature',
-          is_directory: false,
-          size: template_file_size('cucumber', 'example.feature')
-        },
-        { name: '/features/step_definitions', is_directory: true },
-        {
-          name: '/features/step_definitions/common_steps.rb',
-          is_directory: false,
-          size: template_file_size('cucumber', 'common_steps.rb')
-        },
-        { name: '/features/support', is_directory: true },
-        { name: '/features/support/env.rb', is_directory: false, size: template_file_size('cucumber', 'env.rb') },
-        { name: '/features/support/hooks.rb', is_directory: false, size: template_file_size('cucumber', 'hooks.rb') },
-        {
-          name: '/features/support/transformers.rb',
-          is_directory: false,
-          size: template_file_size('cucumber', 'transformers.rb')
-        },
-        { name: '/tasks', is_directory: true },
-        { name: '/tasks/cucumber.rake', is_directory: false, size: template_file_size('cucumber', 'cucumber.rake') },
-        {
-          name: '/tasks/cuke_sniffer.rake',
-          is_directory: false,
-          size: template_file_size('cucumber', 'cuke_sniffer.rake')
-        }
-      ]
-    end
-    it { is_expected.to eql(expected_result) }
-    describe 'output' do
-      let(:expected_output) do
-        "  * Cucumber integration to the framework ...
-      Added 'features/step_definitions/common_steps.rb' file
-      Added 'features/support/env.rb' file
-      Added 'features/support/hooks.rb' file
-      Added 'features/support/transformers.rb' file
-      Added 'features/example.feature' file
-      Added 'tasks/cucumber.rake' file
-      Added 'tasks/cuke_sniffer.rake' file\n"
-      end
-      subject { output.string }
-      it { is_expected.to eql(expected_output) }
-    end
-  end
-end

data/spec/unit/generators/emails_generator_spec.rb

@@ -1,35 +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::EmailsGenerator do
-    let(:generator_name) { described_class }
-    let(:expected_result) do
-      [
-        { name: '/emails', is_directory: true },
-        {
-          name: '/emails/example_email.rb',
-          is_directory: false,
-          size: template_file_size('emails', 'example_email.rb')
-        }
-      ]
-    end
-    it { is_expected.to eql(expected_result) }
-    describe 'output' do
-      let(:expected_output) do
-        "  * Email example generation ...
-      Added '/emails/example_email.rb' file\n"
-      end
-      subject { output.string }
-      it { is_expected.to eql(expected_output) }
-    end
-  end
-end