howitzer 1.1.1 → 2.0.0

data/spec/unit/generators/base_generator_spec.rb

@@ -31,7 +31,8 @@ RSpec.describe Howitzer::BaseGenerator do
   describe 'constructor' do
     let(:list1) { double(:list1) }
     let(:list2) { double(:list2) }
-    subject { described_class.new }
+    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
@@ -45,24 +46,24 @@ RSpec.describe Howitzer::BaseGenerator do
     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
-      subject
+      expect(subject.instance_variable_get(:@options)).to eql options
     end
   end
 
   describe '#manifest' do
-    subject { described_class.new.manifest }
+    subject { described_class.new({}).manifest }
     before { allow_any_instance_of(described_class).to receive(:initialize) { nil } }
     it { is_expected.to be_nil }
   end
 
   describe '#banner' do
-    subject { described_class.new.send(:banner) }
+    subject { described_class.new({}).send(:banner) }
     before { allow_any_instance_of(described_class).to receive(:initialize) { nil } }
     it { is_expected.to be_nil }
   end
 
   describe '#logger' do
-    subject { described_class.new.send(:logger) }
+    subject { described_class.new({}).send(:logger) }
     before { allow_any_instance_of(described_class).to receive(:initialize) { nil } }
     context 'when not specified' do
       before { described_class.instance_variable_set('@logger', nil) }
@@ -76,7 +77,7 @@ RSpec.describe Howitzer::BaseGenerator do
   end
 
   describe '#destination' do
-    subject { described_class.new.send(:destination) }
+    subject { described_class.new({}).send(:destination) }
     before do
       allow_any_instance_of(described_class).to receive(:initialize) { nil }
       allow(described_class).to receive(:destination) { '/' }
@@ -85,9 +86,9 @@ RSpec.describe Howitzer::BaseGenerator do
   end
 
   describe '#copy_files' do
-    let(:list) { [ {source: 'example.txt'} ] }
+    let(:list) { [{ source: 'example.txt' }] }
     let(:source_path) { '/example_path/example.txt' }
-    let(:generator) { described_class.new }
+    let(:generator) { described_class.new({}) }
     subject { generator.send(:copy_files, list) }
     before do
       allow_any_instance_of(described_class).to receive(:initialize) { nil }
@@ -95,23 +96,55 @@ RSpec.describe Howitzer::BaseGenerator do
     end
     after { subject }
     context 'when source_file exists' do
-      before { allow(File).to receive(:exists?).with(source_path) { true } }
+      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(:exists?).with(source_path) { false } }
+      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
-    subject { described_class.new.send(:copy_templates, nil) }
-    before { allow_any_instance_of(described_class).to receive(:initialize) { nil } }
-    it { is_expected.to be_nil }
+    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(:initialize) { 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 }
+    let(:generator) { described_class.new({}) }
     subject { generator.send(:print_banner) }
     before do
       allow_any_instance_of(described_class).to receive(:initialize) { nil }
@@ -129,44 +162,43 @@ RSpec.describe Howitzer::BaseGenerator do
   end
 
   describe '#print_info' do
-    subject { described_class.new.send(:print_info, 'data') }
+    subject { described_class.new({}).send(:print_info, 'data') }
     before { allow_any_instance_of(described_class).to receive(:initialize) { nil } }
     after { subject }
-    it { expect(described_class.logger).to receive(:print).with('      data')}
+    it { expect(described_class.logger).to receive(:print).with('      data') }
   end
 
   describe '#puts_info' do
-    subject { described_class.new.send(:puts_info, 'data') }
+    subject { described_class.new({}).send(:puts_info, 'data') }
     before { allow_any_instance_of(described_class).to receive(:initialize) { nil } }
     after { subject }
-    it { expect(described_class.logger).to receive(:puts).with('      data')}
+    it { expect(described_class.logger).to receive(:puts).with('      data') }
   end
 
   describe '#puts_error' do
-    subject { described_class.new.send(:puts_error, 'data') }
+    subject { described_class.new({}).send(:puts_error, 'data') }
     before { allow_any_instance_of(described_class).to receive(:initialize) { nil } }
     after { subject }
-    it { expect(described_class.logger).to receive(:puts).with('      ERROR: data')}
+    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') }
+    subject { described_class.new({}).send(:source_path, 'example.txt') }
     before do
       allow_any_instance_of(described_class).to receive(:initialize) { nil }
-      allow(File).to receive(:dirname) { '/' }
     end
-    it { is_expected.to eq('/base/templates/example.txt') }
+    it { is_expected.to include('/base/templates/example.txt') }
   end
 
   describe '#dest_path' do
-    subject { described_class.new.send(:dest_path, 'example.txt') }
+    subject { described_class.new({}).send(:dest_path, 'example.txt') }
     before { allow_any_instance_of(described_class).to receive(:initialize) { 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(: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) }
@@ -178,7 +210,7 @@ RSpec.describe Howitzer::BaseGenerator do
     end
     after { subject }
     context 'when destination file present' do
-      before { allow(File).to receive(:exists?).with(dst) { true } }
+      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 }
@@ -192,14 +224,14 @@ RSpec.describe Howitzer::BaseGenerator do
         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(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(FileUtils).to receive(:cp).with(src, dst) { nil }.once
             expect(generator).to receive(:puts_info).with("    Forced 'd.txt' file")
           end
         end
@@ -227,7 +259,7 @@ RSpec.describe Howitzer::BaseGenerator do
       end
     end
     context 'when destination file missing' do
-      before { allow(File).to receive(:exists?).with(dst) { false } }
+      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
@@ -235,8 +267,7 @@ RSpec.describe Howitzer::BaseGenerator do
     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")}
+      it { expect(generator).to receive(:puts_error).with("Impossible to create 'd.txt' file. Reason: Some error") }
     end
   end
-
-end
+end

data/spec/unit/generators/config_generator_spec.rb

@@ -6,17 +6,19 @@ RSpec.describe 'Generators' do
   subject { file_tree_info(destination) }
   before do
     Howitzer::BaseGenerator.logger = output
-    generator_name.new
+    generator_name.new({})
   end
   after { FileUtils.rm_r(destination) }
 
-  describe 'ConfigGenerator' do
-    let(:generator_name) { Howitzer::ConfigGenerator }
+  describe Howitzer::ConfigGenerator do
+    let(:generator_name) { described_class }
     let(:expected_result) do
       [
-          {:name=> '/config', :is_directory=>true},
-          {: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', 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
 
@@ -24,11 +26,13 @@ RSpec.describe 'Generators' do
     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
+end

data/spec/unit/generators/cucumber_generator_spec.rb

@@ -6,25 +6,35 @@ RSpec.describe 'Generators' do
   subject { file_tree_info(destination) }
   before do
     Howitzer::BaseGenerator.logger = output
-    generator_name.new
+    generator_name.new(cucumber: true)
   end
   after { FileUtils.rm_r(destination) }
 
-  describe 'CucumberGenerator' do
-    let(:generator_name) { Howitzer::CucumberGenerator }
+  describe Howitzer::CucumberGenerator do
+    let(:generator_name) { described_class }
     let(:expected_result) do
       [
-          {:name=> '/config', :is_directory=>true},
-          {:name=> '/config/cucumber.yml', :is_directory=>false, :size=>template_file_size('cucumber', 'cucumber.yml')},
-          {: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/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: '/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/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') }
       ]
     end
     it { is_expected.to eql(expected_result) }
@@ -35,11 +45,10 @@ RSpec.describe 'Generators' do
       Added 'features/support/env.rb' file
       Added 'features/support/transformers.rb' file
       Added 'features/example.feature' file
-      Added 'tasks/cucumber.rake' file
-      Added 'config/cucumber.yml' file\n"
+      Added 'tasks/cucumber.rake' file\n"
       end
       subject { output.string }
       it { is_expected.to eql(expected_output) }
     end
   end
-end
+end

data/spec/unit/generators/emails_generator_spec.rb

@@ -6,16 +6,20 @@ RSpec.describe 'Generators' do
   subject { file_tree_info(destination) }
   before do
     Howitzer::BaseGenerator.logger = output
-    generator_name.new
+    generator_name.new({})
   end
   after { FileUtils.rm_r(destination) }
 
-  describe 'EmailsGenerator' do
-    let(:generator_name) { Howitzer::EmailsGenerator }
+  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')}
+        { 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) }
@@ -28,4 +32,4 @@ RSpec.describe 'Generators' do
       it { is_expected.to eql(expected_output) }
     end
   end
-end
+end

data/spec/unit/generators/prerequisites_generator_spec.rb

@@ -0,0 +1,53 @@
+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_girl.rb',
+          is_directory: false, size: template_file_size('prerequisites', 'factory_girl.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
+        "  * Pre-requisites integration to the framework ...
+      Added 'prerequisites/factory_girl.rb' file
+      Added 'prerequisites/factories/users.rb' file
+      Added 'prerequisites/models/base.rb' file
+      Added '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

@@ -6,30 +6,67 @@ RSpec.describe 'Generators' do
   subject { file_tree_info(destination) }
   before do
     Howitzer::BaseGenerator.logger = output
-    generator_name.new
+    generator_name.new(options)
   end
   after { FileUtils.rm_r(destination) }
 
-  describe 'RootGenerator' do
-    let(:generator_name) { Howitzer::RootGenerator }
+  describe Howitzer::RootGenerator do
+    let(:generator_name) { described_class }
     let(:expected_result) do
       [
-          {:name=> '/Gemfile', :is_directory=>false, :size=>template_file_size('root', 'Gemfile')},
-          {:name=> '/Rakefile', :is_directory=>false, :size=>template_file_size('root', 'Rakefile')},
-          {:name=> '/boot.rb', :is_directory=>false, :size=>template_file_size('root', 'boot.rb')}
+        { name: '/.gitignore', is_directory: false, size: 196 },
+        { name: '/.rubocop.yml', is_directory: false, size: 584 },
+        { name: '/Gemfile', is_directory: false, size: 605 },
+        { name: '/Rakefile', is_directory: false, size: template_file_size('root', 'Rakefile') }
       ]
     end
+    let(:options) { {} }
     it { is_expected.to eql(expected_result) }
     describe 'output' do
-      let(:expected_output) do
-        "  * Root files generation ...
+      subject { output.string }
+      context 'when options is empty' do
+        let(:expected_output) do
+          "  * Root files generation ...
       Added '.gitignore' file
-      Added 'Gemfile' file
+      Added '.rubocop.yml' file
       Added 'Rakefile' file
-      Added 'boot.rb' file\n"
+      Added 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
+          "  * Root files generation ...
+      Added '.gitignore' file
+      Added '.rubocop.yml' file
+      Added 'Rakefile' file
+      Added 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
+          "  * Root files generation ...
+      Added '.gitignore' file
+      Added '.rubocop.yml' file
+      Added 'Rakefile' file
+      Added 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
+          "  * Root files generation ...
+      Added '.gitignore' file
+      Added '.rubocop.yml' file
+      Added 'Rakefile' file
+      Added template 'Gemfile.erb' with params '{:turnip=>true}' to destination 'Gemfile'\n"
+        end
+        let(:options) { { turnip: true } }
+        it { is_expected.to eql(expected_output) }
       end
-      subject { output.string }
-      it { is_expected.to eql(expected_output) }
     end
   end
-end
+end