howitzer 2.2.0 → 2.5.0

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

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
-        "#{ColorizedString.new('  * Cucumber integration to the framework ...').light_cyan}
-      #{ColorizedString.new('Added').light_green} 'features/step_definitions/common_steps.rb' file
-      #{ColorizedString.new('Added').light_green} 'features/support/env.rb' file
-      #{ColorizedString.new('Added').light_green} 'features/support/hooks.rb' file
-      #{ColorizedString.new('Added').light_green} 'features/support/transformers.rb' file
-      #{ColorizedString.new('Added').light_green} 'features/example.feature' file
-      #{ColorizedString.new('Added').light_green} 'tasks/cucumber.rake' file
-      #{ColorizedString.new('Added').light_green} '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
-        "#{ColorizedString.new('  * Email example generation ...').light_cyan}
-      #{ColorizedString.new('Added').light_green} '/emails/example_email.rb' file\n"
-      end
-      subject { output.string }
-      it { is_expected.to eql(expected_output) }
-    end
-  end
-end

data/spec/unit/generators/prerequisites_generator_spec.rb

@@ -1,53 +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::PrerequisitesGenerator do
-    let(:generator_name) { described_class }
-    let(:expected_result) do
-      [
-        { name: '/prerequisites', is_directory: true },
-        { name: '/prerequisites/factories', is_directory: true },
-        {
-          name: '/prerequisites/factories/users.rb',
-          is_directory: false, size: template_file_size('prerequisites', 'users.rb')
-        },
-        {
-          name: '/prerequisites/factory_bot.rb',
-          is_directory: false, size: template_file_size('prerequisites', 'factory_bot.rb')
-        },
-        { name: '/prerequisites/models', is_directory: true },
-        {
-          name: '/prerequisites/models/base.rb',
-          is_directory: false,
-          size: template_file_size('prerequisites', 'base.rb')
-        },
-        {
-          name: '/prerequisites/models/user.rb',
-          is_directory: false,
-          size: template_file_size('prerequisites', 'user.rb')
-        }
-      ]
-    end
-    it { is_expected.to eql(expected_result) }
-    describe 'output' do
-      let(:expected_output) do
-        "#{ColorizedString.new('  * Pre-requisites integration to the framework ...').light_cyan}
-      #{ColorizedString.new('Added').light_green} 'prerequisites/factory_bot.rb' file
-      #{ColorizedString.new('Added').light_green} 'prerequisites/factories/users.rb' file
-      #{ColorizedString.new('Added').light_green} 'prerequisites/models/base.rb' file
-      #{ColorizedString.new('Added').light_green} 'prerequisites/models/user.rb' file\n"
-      end
-      subject { output.string }
-      it { is_expected.to eql(expected_output) }
-    end
-  end
-end

data/spec/unit/generators/root_generator_spec.rb

@@ -1,86 +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(options)
-  end
-  after { FileUtils.rm_r(destination) }
-
-  describe Howitzer::RootGenerator do
-    let(:generator_name) { described_class }
-    let(:expected_result) do
-      [
-        { name: '/.gitignore', is_directory: false, size: 196 },
-        { name: '/.rubocop.yml', is_directory: false, size: 616 },
-        { name: '/Gemfile', is_directory: false, size: 811 },
-        { name: '/Rakefile', is_directory: false, size: template_file_size('root', 'Rakefile') }
-      ]
-    end
-    let(:options) { {} }
-
-    it { is_expected.to eql(expected_result) }
-
-    describe 'output' do
-      subject { output.string }
-
-      context 'when options is empty' do
-        let(:expected_output) do
-          added_text = ColorizedString.new('Added').light_green
-          "#{ColorizedString.new('  * Root files generation ...').light_cyan}
-      #{added_text} '.gitignore' file
-      #{added_text} 'Rakefile' file
-      #{added_text} template '.rubocop.yml.erb' with params '{}' to destination '.rubocop.yml'
-      #{added_text} template 'Gemfile.erb' with params '{}' to destination 'Gemfile'\n"
-        end
-
-        it { is_expected.to eql(expected_output) }
-      end
-
-      context 'when options is rspec => true' do
-        let(:expected_output) do
-          added_text = ColorizedString.new('Added').light_green
-          "#{ColorizedString.new('  * Root files generation ...').light_cyan}
-      #{added_text} '.gitignore' file
-      #{added_text} 'Rakefile' file
-      #{added_text} template '.rubocop.yml.erb' with params '{:rspec=>true}' to destination '.rubocop.yml'
-      #{added_text} template 'Gemfile.erb' with params '{:rspec=>true}' to destination 'Gemfile'\n"
-        end
-        let(:options) { { rspec: true } }
-
-        it { is_expected.to eql(expected_output) }
-      end
-
-      context 'when options is cucumber => cucumber' do
-        let(:expected_output) do
-          added_text = ColorizedString.new('Added').light_green
-          "#{ColorizedString.new('  * Root files generation ...').light_cyan}
-      #{added_text} '.gitignore' file
-      #{added_text} 'Rakefile' file
-      #{added_text} template '.rubocop.yml.erb' with params '{:cucumber=>true}' to destination '.rubocop.yml'
-      #{added_text} template 'Gemfile.erb' with params '{:cucumber=>true}' to destination 'Gemfile'\n"
-        end
-        let(:options) { { cucumber: true } }
-
-        it { is_expected.to eql(expected_output) }
-      end
-
-      context 'when options is turnip => true' do
-        let(:expected_output) do
-          added_text = ColorizedString.new('Added').light_green
-          "#{ColorizedString.new('  * Root files generation ...').light_cyan}
-      #{added_text} '.gitignore' file
-      #{added_text} 'Rakefile' file
-      #{added_text} template '.rubocop.yml.erb' with params '{:turnip=>true}' to destination '.rubocop.yml'
-      #{added_text} template 'Gemfile.erb' with params '{:turnip=>true}' to destination 'Gemfile'\n"
-        end
-        let(:options) { { turnip: true } }
-
-        it { is_expected.to eql(expected_output) }
-      end
-    end
-  end
-end

data/spec/unit/generators/rspec_generator_spec.rb

@@ -1,36 +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(rspec: true)
-  end
-  after { FileUtils.rm_r(destination) }
-
-  describe Howitzer::RspecGenerator do
-    let(:generator_name) { described_class }
-    let(:expected_result) do
-      [
-        { name: '/spec', is_directory: true },
-        { name: '/spec/example_spec.rb', is_directory: false, size: template_file_size('rspec', 'example_spec.rb') },
-        { name: '/spec/spec_helper.rb', is_directory: false, size: template_file_size('rspec', 'spec_helper.rb') },
-        { name: '/tasks', is_directory: true },
-        { name: '/tasks/rspec.rake', is_directory: false, size: template_file_size('rspec', 'rspec.rake') }
-      ]
-    end
-    it { is_expected.to eql(expected_result) }
-    describe 'output' do
-      let(:expected_output) do
-        "#{ColorizedString.new('  * RSpec integration to the framework ...').light_cyan}
-      #{ColorizedString.new('Added').light_green} 'spec/spec_helper.rb' file
-      #{ColorizedString.new('Added').light_green} 'spec/example_spec.rb' file
-      #{ColorizedString.new('Added').light_green} 'tasks/rspec.rake' file\n"
-      end
-      subject { output.string }
-      it { is_expected.to eql(expected_output) }
-    end
-  end
-end

data/spec/unit/generators/tasks_generator_spec.rb

@@ -1,31 +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::TasksGenerator do
-    let(:generator_name) { described_class }
-    let(:expected_result) do
-      [
-        { name: '/tasks', is_directory: true },
-        { name: '/tasks/common.rake', is_directory: false, size: template_file_size('tasks', 'common.rake') }
-      ]
-    end
-    it { is_expected.to eql(expected_result) }
-    describe 'output' do
-      let(:expected_output) do
-        "#{ColorizedString.new('  * Base rake task generation ...').light_cyan}
-      #{ColorizedString.new('Added').light_green} 'tasks/common.rake' file\n"
-      end
-      subject { output.string }
-      it { is_expected.to eql(expected_output) }
-    end
-  end
-end