mina 1.2.4 → 1.2.5

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,12 +1,15 @@
+# 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
@@ -15,29 +18,29 @@ describe Mina::Helpers::Internal do
     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

data/spec/lib/mina/runner_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Mina::Runner do
@@ -6,19 +8,13 @@ describe Mina::Runner do
   describe '#initialize' do
     it 'raises an error if execution mode is not set' do
       instance.remove(:execution_mode)
-      expect { Mina::Runner.new(nil, nil) }.to raise_error('You must specify execution mode')
-    end
-
-    it 'raises an error when run on windows and pretty print' do
-      instance.set(:execution_mode, :pretty)
-      allow(Gem::Platform.local).to receive(:os).and_return(:windows)
-      expect { Mina::Runner.new(nil, nil) }.to raise_error('Unsuported execution mode (pretty on windows)')
+      expect { described_class.new(nil, nil) }.to raise_error('You must specify execution mode')
     end
 
     it 'sets execution mode to printer if simulate is true' do
       instance.set(:execution_mode, :pretty)
-      instance.set(:simulate, :true)
-      expect(Mina::Runner.new(nil, nil).execution_mode).to eq(:printer)
+      instance.set(:simulate, true)
+      expect(described_class.new(nil, nil).execution_mode).to eq(:printer)
       instance.remove(:simulate)
     end
   end
@@ -26,7 +22,7 @@ describe Mina::Runner do
   describe '#run' do
     it 'runs the commands on a backend' do
       instance.set(:execution_mode, :printer)
-      runner = Mina::Runner.new(['ls -al'], :local)
+      runner = described_class.new(['ls -al'], :local)
       expect { runner.run }.to output("\\[\\\"ls\\ -al\\\"\\]\n").to_stdout
     end
   end

data/spec/spec_helper.rb

@@ -1,17 +1,22 @@
+# frozen_string_literal: true
+
 require 'simplecov'
 
-SimpleCov.start
+SimpleCov.start do
+  add_filter '/spec/'
 
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
+  enable_coverage :branch
+  primary_coverage :branch
+end
 
 require 'mina'
 require 'rspec'
 require 'pry'
+require 'set'
 
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].sort.each { |f| require f }
 Rake.application = Mina::Application.new
-Dir["./tasks/mina/**/*.rb"].each { |f| require f }
+Dir['./tasks/mina/**/*.rb'].sort.each { |f| require f }
 
 RSpec.configure do |config|
   config.include RakeExampleGroup, type: :rake
@@ -19,16 +24,30 @@ RSpec.configure do |config|
   config.raise_errors_for_deprecations!
   config.order = 'random'
 
-  config.before(:all, type: :rake) do
-    Mina::Configuration.instance.set :simulate, true
-    Mina::Configuration.instance.set :domain, 'localhost'
-    Mina::Configuration.instance.set :deploy_to, "#{Dir.pwd}/deploy"
-    Mina::Configuration.instance.set :repository, "#{Mina.root_path}"
-    Mina::Configuration.instance.set :shared_paths, ['config/database.yml', 'log']
-    Mina::Configuration.instance.set :keep_releases, 2
+  initial_task_names = Rake.application.tasks.to_set(&:name)
+  initial_variables = Mina::Configuration.instance.variables
+
+  config.before do
+    Mina::Configuration.instance.instance_variable_set(:@variables, initial_variables.clone)
+  end
+
+  config.after do
+    Rake.application.tasks.each(&:reenable)
+    Rake.application.instance_variable_get(:@tasks).keep_if { |task_name, _| initial_task_names.include?(task_name) }
+  end
+
+  config.around(:each, :suppressed_output) do |example|
+    original_stdout, $stdout = $stdout, File.open(File::NULL, 'w')
+    original_stderr, $stderr = $stderr, File.open(File::NULL, 'w')
+
+    example.run
+
+    $stdout, $stderr = original_stdout, original_stderr
   end
 
-  config.after(:all, type: :rake) do
-    Mina::Configuration.instance.remove :simulate
+  config.around do |example|
+    example.run
+  rescue SystemExit
+    raise "Unhandled system exit (you're probably missing a raise_error(SystemExit) matcher somewhere)"
   end
 end

data/spec/support/outputs/bundle_clean.txt

@@ -1,2 +1,2 @@
-echo "-----> Cleans up unsed gems"
-bundle clean --without development test --path "vendor/bundle" --deployment
+echo "-----> Cleaning up unused gems"
+bundle clean

data/spec/support/outputs/chruby_with_env.txt

@@ -0,0 +1,7 @@
+echo "-----> chruby to version: \\"123\\""
+if \[\[ ! -s "/etc/profile\.d/chruby\.sh" \]\]; then
+  echo "! chruby\.sh init file not found"
+  exit 1
+fi
+source /etc/profile\.d/chruby\.sh
+chruby "123" \|\| exit 1

data/spec/support/outputs/chruby_without_env.txt

@@ -0,0 +1,2 @@
+Task 'chruby' needs a Ruby version as an argument\.
+Example: invoke :chruby, 'ruby-2.4'

data/spec/support/outputs/debug_configuration_variables.txt

@@ -0,0 +1,11 @@
+========== Configuration variables ==========
+(.|\n)*
+:bundle_bin => "bundle"
+(.|\n)*
+:releases_path => ".*/releases"
+(.|\n)*
+:keep_releases => "1234"
+(.|\n)*
+:migration_dirs => \["db/migrate"\]
+(.|\n)*
+========== Configuration variables ==========

data/spec/support/outputs/dsl_deploy.txt

@@ -0,0 +1,4 @@
+(?m)#!/usr/bin/env bash
+# Executing the following via 'ssh localhost -p 22 -tt':
+.*
+  echo Hello there