mina 1.2.3 → 1.2.5

data/spec/lib/mina/application_spec.rb

@@ -1,39 +1,98 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Mina::Application do
-  # let(:app) { Rake.application }
-  #
-  # %w(quiet silent dry-run).each do |switch|
-  #   it "doesn't include --#{switch} in help" do
-  #     binding.pry
-  #     expect(out).not_to match(/--#{switch}/)
-  #   end
-  # end
-  #
-  # it 'runs adds two default tasks to the task list' do
-  #   expect(subject.top_level_tasks).to include(:debug_configuration_variables)
-  #   expect(subject.top_level_tasks).to include(:run_commands)
-  # end
-  #
-  # it 'overrides the rake method, but still prints the rake version' do
-  #   out = capture_io do
-  #     flags '--version', '-V'
-  #   end
-  #   expect(out).to match(/\bMina, version\b/)
-  #   expect(out).to match(/\bv#{Mina::VERSION}\b/)
-  # end
-  #
-  # it 'enables simulation mode, and sets the backend Mina::Runner::Printer' do
-  #   capture_io do
-  #     flags '--simulate', '-s'
-  #   end
-  #   expect(Mina::Configuration.instance.fetch(:simulate)).to be true
-  # end
-  #
-  # it 'enables printing all config variables on command line parameter' do
-  #   capture_io do
-  #     flags '--debug-configuration-variables', '-d'
-  #   end
-  #   expect(Mina::Configuration.instance.fetch(:debug_configuration_variables)).to be true
-  # end
+  subject(:application) { described_class.new }
+
+  describe '#top_level_tasks' do
+    let(:default_tasks) { ['debug_configuration_variables', 'run_commands'] }
+
+    context 'when `init` task is added' do
+      it 'removes default tasks' do
+        expect do
+          application.collect_command_line_tasks(['init'])
+        end.to change(application, :top_level_tasks).from(default_tasks).to(['init'])
+      end
+    end
+
+    context "when `init` task isn't added" do
+      it 'keeps default tasks' do
+        expect do
+          application.collect_command_line_tasks(['a_task'])
+        end.to change(application, :top_level_tasks).from(default_tasks).to(['a_task', *default_tasks])
+      end
+    end
+  end
+
+  describe 'command-line options' do
+    ['--version', '-V'].each do |option|
+      describe option do
+        it 'prints Mina version and exits' do
+          expect do
+            application.handle_options([option])
+          end.to raise_error(SystemExit)
+             .and output("Mina, version v#{Mina::VERSION}\n").to_stdout
+        end
+      end
+    end
+
+    ['--verbose', '-v'].each do |option|
+      describe option do
+        it 'sets verbose flag to true' do
+          expect do
+            application.handle_options([option])
+          end.to change { application.fetch(:verbose) }.from(nil).to(true)
+        end
+      end
+    end
+
+    ['--simulate', '-s'].each do |option|
+      describe option do
+        it 'sets simulate flag to true' do
+          expect do
+            application.handle_options([option])
+          end.to change { application.fetch(:simulate) }.from(nil).to(true)
+        end
+      end
+    end
+
+    ['--debug-configuration-variables', '-d'].each do |option|
+      describe option do
+        it 'sets debug_configuration_variables flag to true' do
+          expect do
+            application.handle_options([option])
+          end.to change { application.fetch(:debug_configuration_variables) }.from(nil).to(true)
+        end
+      end
+    end
+
+    describe '--no-report-time' do
+      it 'sets skip_report_time flag to true' do
+        expect do
+          application.handle_options(['--no-report-time'])
+        end.to change { application.fetch(:skip_report_time) }.from(nil).to(true)
+      end
+    end
+  end
+
+  describe 'Rake options' do
+    let(:options) { application.standard_rake_options }
+
+    it 'shows --verbose' do
+      expect(options.any? { |(switch, *)| switch == '--verbose' }).to eq(true)
+    end
+
+    it "doesn't show --dry-run" do
+      expect(options.any? { |(switch, *)| switch == '--dry-run' }).to eq(false)
+    end
+
+    it "doesn't show --quiet" do
+      expect(options.any? { |(switch, *)| switch == '--quiet' }).to eq(false)
+    end
+
+    it "doesn't show --silent" do
+      expect(options.any? { |(switch, *)| switch == '--silent' }).to eq(false)
+    end
+  end
 end

data/spec/lib/mina/backend/local_spec.rb

@@ -1,11 +1,14 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Mina::Backend::Local do
-  let(:backend) { Mina::Backend::Local.new ['ls -al'] }
+  let(:backend) { described_class.new ['ls -al'] }
+
   describe '#prepare' do
     it 'escpaces shellwords' do
       Mina::Configuration.instance.remove(:simulate)
-      expect(backend.prepare).to eq("\\[\\\"ls\\ -al\\\"\\]")
+      expect(backend.prepare).to eq('\\[\\"ls\\ -al\\"\\]')
     end
 
     it 'adds debug if simualte' do

data/spec/lib/mina/backend/remote_spec.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Mina::Backend::Remote do
-  let(:backend) { Mina::Backend::Remote.new ['ls -al'] }
+  let(:backend) { described_class.new ['ls -al'] }
+
   before { Mina::Configuration.instance.set(:domain, 'localhost') }
-  after { Mina::Configuration.instance.remove(:domain) }
 
   describe '#prepare' do
     it 'escpaces shellwords' do
-      expect(backend.prepare).to eq("ssh localhost -p 22 -tt -- \\[\\\"ls\\ -al\\\"\\]")
+      expect(backend.prepare).to eq('ssh localhost -p 22 -tt -- \\[\\"ls\\ -al\\"\\]')
     end
 
     it 'adds debug if simualte' do

data/spec/lib/mina/commands_spec.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Mina::Commands do
-  let(:commands) { Mina::Commands.new(:default) }
+  let(:commands) { described_class.new(:default) }
 
   describe '#command' do
     it 'adds a command to the queue' do
@@ -18,7 +20,6 @@ describe Mina::Commands do
 
     context 'when verbose' do
       before { Mina::Configuration.instance.set(:verbose, true) }
-      after { Mina::Configuration.instance.remove(:verbose) }
 
       it 'adds a echo command to the queue' do
         commands.command('ls -al')
@@ -73,20 +74,19 @@ describe Mina::Commands do
 
     context 'when verbose' do
       before { Mina::Configuration.instance.set(:verbose, true) }
-      after { Mina::Configuration.instance.remove(:verbose) }
 
       it 'joins all the commands within a path and echoes it' do
-        expect(commands.process('some/path')).to eq("(cd some/path && echo \"$ cd some/path\" && ls -al && pwd && cd -)")
+        expect(commands.process('some/path')).to eq('(cd some/path && echo "$ cd some/path" && ls -al && pwd && cd -)')
       end
     end
   end
 
   describe '#run' do
-    it 'calls run on a backend' do
+    it 'calls run on a backend', :suppressed_output do
       commands.command('ls -al')
-      runner = double(:runner)
+      runner = instance_double(Mina::Runner)
       allow(Mina::Runner).to receive(:new).and_return(runner)
-      expect(runner).to receive(:run).and_return(true)
+      allow(runner).to receive(:run).and_return(true)
       commands.run(:local)
     end
   end

data/spec/lib/mina/configuration_spec.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Mina::Configuration do
-  let(:config) { Class.new(Mina::Configuration).instance }
+  let(:config) { Class.new(described_class).instance }
   let(:key) { config.fetch(:key, :default) }
 
   describe '#set' do
@@ -26,6 +28,44 @@ describe Mina::Configuration do
       expect(key).to eq 'env'
       ENV['key'] = nil
     end
+
+    it "returns nil if a default value isn't provided" do
+      expect(config.fetch(:key)).to eq(nil)
+    end
+  end
+
+  describe '#remove' do
+    context 'when key exists' do
+      before do
+        config.set(:key, :value)
+      end
+
+      it 'removes the key' do
+        expect(config.set?(:key)).to eq(true)
+
+        config.remove(:key)
+
+        expect(config.set?(:key)).to eq(false)
+      end
+
+      it 'returns key value' do
+        expect(config.remove(:key)).to eq(:value)
+      end
+    end
+
+    context "when key doesn't exist" do
+      it "doesn't do anything" do
+        expect(config.set?(:key)).to eq(false)
+
+        config.remove(:key)
+
+        expect(config.set?(:key)).to eq(false)
+      end
+
+      it 'returns nil' do
+        expect(config.remove(:key)).to eq(nil)
+      end
+    end
   end
 
   describe '#set?' do
@@ -34,6 +74,11 @@ describe Mina::Configuration do
       expect(config.set?(:key)).to be true
     end
 
+    it 'returns false if key is set with nil value' do
+      config.set(:key, nil)
+      expect(config.set?(:key)).to be false
+    end
+
     it 'returns false if key is not set' do
       expect(config.set?(:key)).to be false
     end
@@ -42,11 +87,26 @@ describe Mina::Configuration do
   describe '#ensure!' do
     it 'does not raise error if key is set' do
       config.set(:key, :value)
-      expect { config.ensure!(:key) }.to_not raise_error
+      expect { config.ensure!(:key) }.not_to raise_error
     end
 
     it 'raises an error if key is not set' do
       expect { config.ensure!(:key) }.to raise_error(SystemExit)
+                                     .and output(/key must be defined!/).to_stdout
+    end
+  end
+
+  describe '#reset!' do
+    before do
+      config.set(:key, :value)
+    end
+
+    it 'cleans all variables' do
+      expect(config.variables).not_to be_empty
+
+      config.reset!
+
+      expect(config.variables).to be_empty
     end
   end
 
@@ -55,7 +115,7 @@ describe Mina::Configuration do
     let(:host) { host_class.new }
 
     [:fetch, :set].each do |method|
-      it "should respond to #{method}" do
+      it "responds to #{method}" do
         expect(host).to respond_to(method)
       end
     end

data/spec/lib/mina/dsl_spec.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Mina::DSL, type: :rake do
+  before do
+    load_default_config
+    load_config 'dsl'
+  end
+
+  describe '#reset!' do
+    let(:task_name) { 'reset_task' }
+
+    it 'clears all commands before it' do
+      expect do
+        invoke_all
+      end.to output(output_file('dsl_reset')).to_stdout
+    end
+  end
+
+  describe '#run' do
+    context 'when one run block is inside another' do
+      let(:task_name) { 'one_run_inside_another' }
+
+      it 'exits with an error message' do
+        expect do
+          invoke_all
+        end.to raise_error(SystemExit)
+           .and output(/Can't use run block inside another run block./).to_stdout
+      end
+    end
+
+    context 'when backend is :local' do
+      let(:task_name) { 'local_run' }
+
+      it 'executes commands locally' do
+        expect do
+          invoke_all
+        end.to output(output_file('dsl_local_run')).to_stdout
+      end
+    end
+
+    context 'when backend is :remote' do
+      let(:task_name) { 'remote_run' }
+
+      it 'executes commands on the server' do
+        expect do
+          invoke_all
+        end.to output(output_file('dsl_remote_run')).to_stdout
+      end
+    end
+
+    context "when backend doesn't exist" do
+      let(:task_name) { 'nonexistent_run' }
+
+      # TODO: refactor for more user-friendly error handling
+      it 'raises a runtime error' do
+        expect do
+          invoke_all
+        end.to raise_error(RuntimeError, /Don't know how to build task 'nonexistent_environment'/)
+      end
+    end
+  end
+
+  describe '#on' do
+    let(:task_name) { 'on_stage_task' }
+
+    it 'executes the command in the given stage' do
+      expect do
+        invoke_all
+      end.to output(output_file('dsl_on')).to_stdout
+    end
+  end
+
+  describe '#in_path' do
+    let(:task_name) { 'in_path_task' }
+
+    it 'executes the command in the given path' do
+      expect do
+        invoke_all
+      end.to output(output_file('dsl_in_path')).to_stdout
+    end
+  end
+
+  describe '#deploy' do
+    let(:task_name) { 'deploy_block_task' }
+
+    it 'executes the deploy script and commands on remote' do
+      expect do
+        invoke_all
+      end.to output(output_file('dsl_deploy')).to_stdout
+    end
+  end
+end

data/spec/lib/mina/helpers/internal_spec.rb

@@ -1,43 +1,46 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Mina::Helpers::Internal do
-  class DummyInternalHelper
-    include Mina::DSL
-    include Mina::Helpers::Internal
+  let(:dummy_class) do
+    Class.new do
+      include Mina::DSL
+      include Mina::Helpers::Internal
+    end
   end
-
-  let(:helper) { DummyInternalHelper.new }
+  let(:helper) { dummy_class.new }
 
   describe '#deploy_script' do
     before do
-      Mina::Configuration.instance.set(:deploy_script, 'data/deploy.sh.erb')
+      Mina::Configuration.instance.set(:deploy_script, Mina.root_path('data/deploy.sh.erb'))
       Mina::Configuration.instance.set(:version_scheme, :sequence)
     end
 
     it 'returns whole script' do
-      expect(helper.deploy_script {}).to_not be_empty
+      expect(helper.deploy_script {}).not_to be_empty
     end
   end
 
   describe '#erb' do
     before { Mina::Configuration.instance.set(:version_scheme, :sequence) }
-    after { Mina::Configuration.instance.remove(:version_scheme) }
 
     it 'returns whole script' do
-      expect(helper.erb('data/deploy.sh.erb')).to_not be_empty
+      expect(helper.erb('data/deploy.sh.erb')).not_to be_empty
     end
   end
 
   describe '#echo_cmd' do
     context 'when not verbose' do
-      it 'reuturns unedited code' do
+      before { Mina::Configuration.instance.set(:verbose, false) }
+
+      it 'returns unedited code' do
         expect(helper.echo_cmd('ls -al')).to eq('ls -al')
       end
     end
 
     context 'when verbose' do
       before { Mina::Configuration.instance.set(:verbose, true) }
-      after { Mina::Configuration.instance.remove(:verbose) }
 
       it 'modifies code' do
         expect(helper.echo_cmd('ls -al')).to eq("echo \\$\\ ls\\ -al &&\nls -al")
@@ -54,4 +57,79 @@ describe Mina::Helpers::Internal do
       expect(helper.indent(4, 'ls -al')).to eq('    ls -al')
     end
   end
+
+  describe '#unindent' do
+    it 'unindents code' do
+      expect(helper.unindent("    ls -al\n")).to eq('ls -al')
+    end
+  end
+
+  describe '#report_time' do
+    context 'when :skip_report_time is true' do
+      before { Mina::Configuration.instance.set(:skip_report_time, true) }
+
+      it "doesn't output report time" do
+        expect do
+          helper.report_time {}
+        end.not_to output.to_stdout
+      end
+    end
+
+    context 'when :skip_report_time is false' do
+      before { Mina::Configuration.instance.set(:skip_report_time, false) }
+
+      it 'outputs report time' do
+        expect do
+          helper.report_time {}
+        end.to output(/Elapsed time: \d+\.\d\d seconds/).to_stdout
+      end
+    end
+  end
+
+  describe '#next_version' do
+    before do
+      Mina::Configuration.instance.set(:releases_path, '/releases')
+    end
+
+    context 'when :version_scheme is :datetime' do
+      before do
+        Mina::Configuration.instance.set(:version_scheme, :datetime)
+
+        allow(Time).to receive(:now).and_return(Time.parse('2020-05-01 12:34:56 UTC'))
+      end
+
+      after { Mina::Configuration.instance.remove(:version_scheme) }
+
+      it 'formats current UTC time' do
+        expect(helper.next_version).to eq('20200501123456')
+      end
+    end
+
+    context 'when :version_scheme is :sequence' do
+      before { Mina::Configuration.instance.set(:version_scheme, :sequence) }
+
+      it 'generates a command to calculate the next version' do
+        expect(helper.next_version).to eq('$((`ls -1 /releases | sort -n | tail -n 1`+1))')
+      end
+    end
+
+    context 'when :version_scheme is unknown' do
+      before { Mina::Configuration.instance.set(:version_scheme, :foobar) }
+
+      it 'exits with an error message' do
+        expect do
+          helper.next_version
+        end.to raise_error(SystemExit)
+           .and output(/Unrecognized version scheme\. Use :datetime or :sequence/).to_stdout
+      end
+    end
+  end
+
+  describe '#error!' do
+    it 'exits with an error message' do
+      expect do
+        helper.error!('foobar')
+      end.to raise_error(SystemExit).and output(/foobar/).to_stdout
+    end
+  end
 end

data/spec/lib/mina/helpers/output_spec.rb

@@ -1,33 +1,36 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Mina::Helpers::Output do
-  class DummyOutputHelper
-    include Mina::Helpers::Output
-  end
-
-  let(:helper) { DummyOutputHelper.new }
+  let(:dummy_class) { Class.new { include Mina::Helpers::Output } }
+  let(:helper) { dummy_class.new }
 
   describe '#print_line' do
     it 'prints normally' do
-      expect{ helper.print_line('ls -al') }.to output("       ls -al\n").to_stdout
+      expect { helper.print_line('ls -al') }.to output("       ls -al\n").to_stdout
     end
 
     it 'prints comment' do
-      expect{ helper.print_line('-> ls -al') }.to output("\e[32m----->\e[0m ls -al\n").to_stdout
+      expect { helper.print_line('-> ls -al') }.to output("\e[32m----->\e[0m ls -al\n").to_stdout
     end
 
     it 'prints error' do
-      expect{ helper.print_line('! ls -al') }.to output(" \e[33m!\e[0m     \e[31mls -al\e[0m\n").to_stdout
+      expect { helper.print_line('! ls -al') }.to output(" \e[33m!\e[0m     \e[31mls -al\e[0m\n").to_stdout
     end
 
     it 'prints command' do
-      expect{ helper.print_line('$ ls -al') }.to output("       \e[36m$\e[0m \e[36mls -al\e[0m\n").to_stdout
+      expect { helper.print_line('$ ls -al') }.to output("       \e[36m$\e[0m \e[36mls -al\e[0m\n").to_stdout
     end
   end
 
   describe '#print_stderr' do
+    it 'prints normally when the message is formatted by assets precompile' do
+      expect { helper.print_stderr('I, [ ls -al') }.to output("       I, [ ls -al\n").to_stdout
+    end
+
     it 'prints stderr' do
-      expect{ helper.print_stderr('ls -al') }.to output("       \e[31mls -al\e[0m\n").to_stdout
+      expect { helper.print_stderr('ls -al') }.to output("       \e[31mls -al\e[0m\n").to_stdout
     end
   end
 end

data/spec/lib/mina/runner/exec_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Mina::Runner::Exec do
+  subject(:runner) { described_class.new('echo hello') }
+
+  describe '#run' do
+    before do
+      allow(Kernel).to receive(:exec)
+    end
+
+    it 'executes the script' do
+      runner.run
+
+      expect(Kernel).to have_received(:exec).with('echo hello')
+    end
+  end
+end

data/spec/lib/mina/runner/pretty_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Mina::Runner::Pretty do
+  subject(:runner) { described_class.new('true') }
+
+  describe '#run', :suppressed_output do
+    it 'executes the script' do
+      expect { runner.run }.to output('').to_stdout
+    end
+
+    it 'returns true', :suppressed_output do
+      expect(runner.run).to eq(true)
+    end
+  end
+end

data/spec/lib/mina/runner/printer_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Mina::Runner::Printer do
+  subject(:runner) { described_class.new('echo hello') }
+
+  describe '#run' do
+    it 'prints the script to stdout' do
+      expect do
+        runner.run
+      end.to output("echo hello\n").to_stdout
+    end
+
+    it 'returns true', :suppressed_output do
+      expect(runner.run).to eq(true)
+    end
+  end
+end

data/spec/lib/mina/runner/system_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Mina::Runner::System do
+  subject(:runner) { described_class.new('echo hello') }
+
+  describe '#run' do
+    before do
+      allow(Kernel).to receive(:system)
+    end
+
+    it 'executes the script' do
+      runner.run
+
+      expect(Kernel).to have_received(:system).with('echo hello')
+    end
+  end
+end