producer-core 0.1.12 → 0.1.13

data/spec/producer/core/remote/fs_spec.rb

@@ -1,97 +1,88 @@
 require 'spec_helper'
 
 module Producer::Core
-  describe Remote::FS do
-    let(:remote)  { Remote.new('some_host.example') }
-    subject(:fs)  { Remote::FS.new(remote) }
-
-    describe '#new' do
-      it 'assigns the remote given as argument' do
-        expect(fs.remote).to be remote
+  class Remote
+    describe FS do
+      let(:sftp_file) { double 'sftp_file' }
+      let(:sftp)      { double('sftp', file: sftp_file) }
+      subject(:fs)    { FS.new(sftp) }
+
+      describe '#initialize' do
+        it 'assigns the sftp session' do
+          expect(fs.sftp).to be sftp
+        end
       end
-    end
 
-    describe '#sftp', :ssh do
-      before { sftp_story }
+      describe '#dir?' do
+        let(:path)  { 'some_directory_path' }
+        let(:stat)  { double 'stat' }
 
-      it 'builds a new SFTP session' do
-        expect(remote.session.sftp).to receive :connect
-        fs.sftp
-      end
+        before { allow(sftp).to receive(:stat!).with(path) { stat } }
 
-      it 'returns the new SFTP session' do
-        session = double 'session'
-        allow(remote.session.sftp).to receive(:connect) { session }
-        expect(fs.sftp).to be session
-      end
+        context 'when path given as argument is a directory' do
+          before { allow(stat).to receive(:directory?) { true } }
 
-      it 'memoizes the FS' do
-        allow(remote.session.sftp).to receive(:connect) { Object.new }
-        expect(fs.sftp).to be fs.sftp
-      end
-    end
-
-    describe '#dir?' do
-      let(:sftp)  { double('sftp').as_null_object }
-      let(:path)  { 'some_directory_path' }
-      let(:stat)  { double 'stat' }
-
-      before do
-        allow(fs).to receive(:sftp) { sftp }
-        allow(sftp).to receive(:stat!).with(path) { stat }
-      end
+          it 'returns true' do
+            expect(fs.dir? path).to be true
+          end
+        end
 
-      context 'when path given as argument is a directory' do
-        before { allow(stat).to receive(:directory?) { true } }
+        context 'when path given as argument is not a directory' do
+          before { allow(stat).to receive(:directory?) { false } }
 
-        it 'returns true' do
-          expect(fs.dir? path).to be true
+          it 'returns false' do
+            expect(fs.dir? path).to be false
+          end
         end
-      end
 
-      context 'when path given as argument is not a directory' do
-        before { allow(stat).to receive(:directory?) { false } }
+        context 'when querying the path raises a Net::SFTP::StatusException' do
+          before do
+            response = double 'response', code: '42', message: 'some message'
+            ex = Net::SFTP::StatusException.new(response)
+            allow(sftp).to receive(:stat!).with(path).and_raise(ex)
+          end
 
-        it 'returns false' do
-          expect(fs.dir? path).to be false
+          it 'returns false' do
+            expect(fs.dir? path).to be false
+          end
         end
       end
 
-      context 'when querying the path raises a Net::SFTP::StatusException' do
+      # FIXME: We rely a lot on mocking net-sftp heavily, while we already use a
+      # part of net-ssh story helpers, which are more close to integration tests.
+      describe '#file?', :ssh do
+        let(:file_path) { 'some_file_path' }
+        let(:stat)      { double 'stat' }
+
         before do
-          response = double 'response', code: '42', message: 'some message'
-          ex = Net::SFTP::StatusException.new(response)
-          allow(sftp).to receive(:stat!).with(path).and_raise(ex)
+          sftp_story
+          allow(fs.sftp).to receive(:stat!) { stat }
         end
 
-        it 'returns false' do
-          expect(fs.dir? path).to be false
-        end
-      end
-    end
-
-    # FIXME: We rely a lot on mocking net-sftp heavily, while we already use a
-    # part of net-ssh story helpers, which are more close to integration tests.
-    describe '#file?', :ssh do
-      let(:file_path) { 'some_file_path' }
-      let(:stat)      { double 'stat' }
+        context 'when path given as argument exists' do
+          context 'when path is a file' do
+            before { allow(stat).to receive(:file?) { true } }
 
-      before do
-        sftp_story
-        allow(fs.sftp).to receive(:stat!) { stat }
-      end
+            it 'returns true' do
+              expect(fs.file? file_path).to be true
+            end
+          end
 
-      context 'when path given as argument exists' do
-        context 'when path is a file' do
-          before { allow(stat).to receive(:file?) { true } }
+          context 'when path is not a file' do
+            before { allow(stat).to receive(:file?) { false } }
 
-          it 'returns true' do
-            expect(fs.file? file_path).to be true
+            it 'returns false' do
+              expect(fs.file? file_path).to be false
+            end
           end
         end
 
-        context 'when path is not a file' do
-          before { allow(stat).to receive(:file?) { false } }
+        context 'when querying the path raises a Net::SFTP::StatusException' do
+          before do
+            response = double 'response', code: '42', message: 'some message'
+            ex = Net::SFTP::StatusException.new(response)
+            allow(stat).to receive(:file?).and_raise(ex)
+          end
 
           it 'returns false' do
             expect(fs.file? file_path).to be false
@@ -99,53 +90,58 @@ module Producer::Core
         end
       end
 
-      context 'when querying the path raises a Net::SFTP::StatusException' do
-        before do
-          response = double 'response', code: '42', message: 'some message'
-          ex = Net::SFTP::StatusException.new(response)
-          allow(stat).to receive(:file?).and_raise(ex)
-        end
+      describe '#mkdir' do
+        let(:path) { 'some_directory_path' }
 
-        it 'returns false' do
-          expect(fs.file? file_path).to be false
+        it 'creates the directory' do
+          expect(sftp).to receive(:mkdir!).with(path)
+          fs.mkdir path
         end
       end
-    end
 
-    describe '#mkdir' do
-      let(:sftp)  { double 'sftp' }
-      let(:path)  { 'some_directory_path' }
+      describe '#file_read' do
+        let(:f)       { double 'f' }
+        let(:path)    { 'some_file_path' }
+        let(:content) { 'some_content' }
 
-      before { allow(fs).to receive(:sftp) { sftp } }
+        before do
+          allow(sftp_file).to receive(:open).and_yield(f)
+          allow(f).to receive(:read) { content }
+        end
 
-      it 'creates the directory' do
-        expect(sftp).to receive(:mkdir!).with(path)
-        fs.mkdir path
-      end
-    end
+        it 'returns the file content' do
+          expect(fs.file_read(path)).to eq content
+        end
 
-    describe '#file_write' do
-      let(:sftp)    { double('sftp').as_null_object }
-      let(:file)    { double('sftp').as_null_object }
-      let(:path)    { 'some_file_path' }
-      let(:content) { 'some_content' }
+        context 'when opening the file raises a Net::SFTP::StatusException' do
+          before do
+            response = double 'response', code: '42', message: 'some message'
+            ex = Net::SFTP::StatusException.new(response)
+            allow(sftp_file).to receive(:open).and_raise(ex)
+          end
 
-      before do
-        allow(fs).to receive(:sftp) { sftp }
-        allow(sftp).to receive(:file) { file }
+          it 'returns nil' do
+            expect(fs.file_read(path)).to be nil
+          end
+        end
       end
 
-      it 'opens the file' do
-        expect(file).to receive(:open).with(path, 'w')
-        fs.file_write path, content
-      end
+      describe '#file_write' do
+        let(:path)    { 'some_file_path' }
+        let(:content) { 'some_content' }
 
-      it 'writes the content' do
-        expect(file).to receive(:open).with(any_args) do |&b|
-          expect(file).to receive(:write).with(content)
-          b.call file
+        it 'opens the file' do
+          expect(sftp_file).to receive(:open).with(path, 'w')
+          fs.file_write path, content
+        end
+
+        it 'writes the content' do
+          expect(sftp_file).to receive(:open).with(any_args) do |&b|
+            expect(sftp_file).to receive(:write).with(content)
+            b.call sftp_file
+          end
+          fs.file_write path, content
         end
-        fs.file_write path, content
       end
     end
   end

data/spec/producer/core/remote_spec.rb

@@ -68,20 +68,11 @@ module Producer::Core
     end
 
     describe '#fs' do
-      it 'builds a new FS' do
-        expect(Remote::FS).to receive :new
-        remote.fs
-      end
-
-      it 'returns the new FS instance' do
-        fs = double 'fs'
-        allow(Remote::FS).to receive(:new) { fs }
-        expect(remote.fs).to be fs
-      end
+      let(:sftp_session) { double 'sftp session' }
 
-      it 'memoizes the FS' do
-        allow(Remote::FS).to receive(:new) { Object.new }
-        expect(remote.fs).to be remote.fs
+      it 'returns an FS instance built with a new sftp session' do
+        remote.stub_chain(:session, :sftp, :connect) { sftp_session }
+        expect(remote.fs.sftp).to be sftp_session
       end
     end
 

data/spec/producer/core/task/dsl_spec.rb

@@ -1,105 +1,115 @@
 require 'spec_helper'
 
 module Producer::Core
-  describe Task::DSL do
-    let(:block)   { proc {} }
-    let(:env)     { Env.new }
-    subject(:dsl) { Task::DSL.new(env, &block) }
-
-    %w[echo sh mkdir file_write].each do |action|
-      it "has `#{action}' action defined" do
-        expect(dsl).to respond_to action.to_sym
+  class Task
+    describe DSL do
+      let(:block)   { proc {} }
+      let(:env)     { Env.new }
+      subject(:dsl) { DSL.new(env, &block) }
+
+      %w[echo sh mkdir file_write file_replace_content].each do |action|
+        it "has `#{action}' action defined" do
+          expect(dsl).to respond_to action.to_sym
+        end
       end
-    end
-
-    describe '.define_action' do
-      let(:some_action_class) { Class.new(Action) }
 
-      before { described_class.define_action(:some_action, some_action_class) }
+      describe '.define_action' do
+        let(:some_action_class) { Class.new(Action) }
 
-      it 'defines a new action keyword' do
-        expect(dsl).to respond_to :some_action
-      end
+        before { described_class.define_action(:some_action, some_action_class) }
 
-      context 'when an action keyword is called' do
-        it 'registers the action' do
-          expect { dsl.some_action }.to change { dsl.actions.count }.by 1
+        it 'defines a new action keyword' do
+          expect(dsl).to respond_to :some_action
         end
 
-        it 'registers the action with current env' do
-          dsl.some_action
-          expect(dsl.actions.first.env).to be env
-        end
+        context 'when an action keyword is called' do
+          it 'registers the action' do
+            expect { dsl.some_action }.to change { dsl.actions.count }.by 1
+          end
+
+          it 'registers the action with current env' do
+            dsl.some_action
+            expect(dsl.actions.first.env).to be env
+          end
 
-        it 'registers the action with given arguments' do
-          dsl.some_action :some, :args
-          expect(dsl.actions.first.arguments).to eq [:some, :args]
+          it 'registers the action with given arguments' do
+            dsl.some_action :some, :args
+            expect(dsl.actions.first.arguments).to eq [:some, :args]
+          end
         end
       end
-    end
 
-    describe '#initialize' do
-      it 'assigns the given env' do
-        expect(dsl.env).to be env
-      end
+      describe '#initialize' do
+        it 'assigns the given env' do
+          expect(dsl.env).to be env
+        end
 
-      it 'assigns the given block' do
-        expect(dsl.block).to be block
-      end
+        it 'assigns the given block' do
+          expect(dsl.block).to be block
+        end
 
-      it 'assigns no action' do
-        expect(dsl.actions).to be_empty
-      end
+        it 'assigns no action' do
+          expect(dsl.actions).to be_empty
+        end
 
-      it 'assigns true as the condition' do
-        expect(dsl.condition).to be true
+        it 'assigns true as the condition' do
+          expect(dsl.condition).to be true
+        end
       end
-    end
 
-    describe '#evaluate' do
-      let(:block) { proc { throw :task_code } }
+      describe '#evaluate' do
+        let(:block) { proc { throw :task_code } }
 
-      it 'evaluates its code' do
-        expect { dsl.evaluate }
-          .to throw_symbol :task_code
-      end
+        it 'evaluates its code' do
+          expect { dsl.evaluate }
+            .to throw_symbol :task_code
+        end
 
-      context 'when arguments are given' do
-        let(:block) { proc { |e| throw e } }
+        context 'when arguments are given' do
+          let(:block) { proc { |e| throw e } }
 
-        it 'passes arguments as block parameters' do
-          expect { dsl.evaluate :some_argument }
-            .to throw_symbol :some_argument
+          it 'passes arguments as block parameters' do
+            expect { dsl.evaluate :some_argument }
+              .to throw_symbol :some_argument
+          end
         end
       end
-    end
 
-    describe '#condition' do
-      context 'when a block is given' do
-        it 'assigns a new evaluated condition' do
-          dsl.condition { :some_return_value }
-          expect(dsl.condition.return_value).to eq :some_return_value
+      describe '#condition' do
+        context 'when a block is given' do
+          it 'assigns a new evaluated condition' do
+            dsl.condition { :some_return_value }
+            expect(dsl.condition.return_value).to eq :some_return_value
+          end
         end
       end
-    end
 
-    describe '#ask' do
-      let(:question)        { 'Which letter?' }
-      let(:choices)         { [[:a, ?A], [:b, ?B]] }
-      let(:prompter_class)  { double('prompter class').as_null_object }
-      subject(:ask)         { dsl.ask question, choices,
-                              prompter: prompter_class }
+      describe '#ask' do
+        let(:question)        { 'Which letter?' }
+        let(:choices)         { [[:a, ?A], [:b, ?B]] }
+        let(:prompter_class)  { double('prompter class').as_null_object }
+        subject(:ask)         { dsl.ask question, choices,
+                                prompter: prompter_class }
+
+        it 'builds a prompter' do
+          expect(prompter_class).to receive(:new).with(env.input, env.output)
+          ask
+        end
 
-      it 'builds a prompter' do
-        expect(prompter_class).to receive(:new).with(env.input, env.output)
-        ask
+        it 'prompts and returns the choice' do
+          prompter = double 'prompter'
+          allow(prompter_class).to receive(:new) { prompter }
+          allow(prompter).to receive(:prompt) { :choice }
+          expect(ask).to eq :choice
+        end
       end
 
-      it 'prompts and returns the choice' do
-        prompter = double 'prompter'
-        allow(prompter_class).to receive(:new) { prompter }
-        allow(prompter).to receive(:prompt) { :choice }
-        expect(ask).to eq :choice
+      describe '#get' do
+        let(:env) { Env.new(registry: { some_key: :some_value }) }
+
+        it 'fetches a value from the registry at given index' do
+          expect(dsl.get :some_key).to eq :some_value
+        end
       end
     end
   end

data/spec/producer/core/task_spec.rb

@@ -49,7 +49,7 @@ module Producer::Core
       end
 
       context 'when only the name is given as argument' do
-        subject(:task) { Task.new(name) }
+        subject(:task) { described_class.new(name) }
 
         it 'assigns no action' do
           expect(task.actions).to be_empty

data/spec/producer/core/test_spec.rb

@@ -2,82 +2,6 @@ require 'spec_helper'
 
 module Producer::Core
   describe Test do
-    let(:env)         { Env.new }
-    let(:arguments)   { [:some, :arguments] }
-    subject(:test)    { Test.new(env, *arguments) }
-
-    describe '#initialize' do
-      it 'assigns the env' do
-        expect(test.env).to be env
-      end
-
-      it 'assigns the arguments' do
-        expect(test.arguments).to eq arguments
-      end
-
-      it 'assigns negated as false by default' do
-        expect(test).to_not be_negated
-      end
-
-      context 'when negated option is true' do
-        subject(:test) { described_class.new(env, *arguments, negated: true) }
-
-        it 'assigns negated as true' do
-          expect(test).to be_negated
-        end
-      end
-    end
-
-    describe '#remote' do
-      it 'returns env remote' do
-        expect(test.remote).to be test.env.remote
-      end
-    end
-
-    describe '#fs' do
-      it 'returns env remote fs' do
-        expect(test.fs).to be test.env.remote.fs
-      end
-    end
-
-    describe '#negated?' do
-      it 'returns false' do
-        expect(test.negated?).to be false
-      end
-
-      context 'when test is negated' do
-        subject(:test) { described_class.new(env, *arguments, negated: true) }
-
-        it 'returns true' do
-          expect(test.negated?).to be true
-        end
-      end
-    end
-
-    describe '#pass?' do
-      it 'returns true when #verify is true' do
-        allow(test).to receive(:verify) { true }
-        expect(test.pass?).to be true
-      end
-
-      it 'returns false when #verify is false' do
-        allow(test).to receive(:verify) { false }
-        expect(test.pass?).to be false
-      end
-
-      context 'when test is negated' do
-        subject(:test) { described_class.new(env, *arguments, negated: true) }
-
-        it 'returns false when #verify is true' do
-          allow(test).to receive(:verify) { true }
-          expect(test.pass?).to be false
-        end
-
-        it 'returns true when #verify is false' do
-          allow(test).to receive(:verify) { false }
-          expect(test.pass?).to be true
-        end
-      end
-    end
+    it_behaves_like 'test'
   end
 end

data/spec/producer/core/testing/mock_remote_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'producer/core/testing'
+
+module Producer::Core
+  module Testing
+    describe MockRemote do
+      subject(:remote) { MockRemote.new('some_host.example') }
+
+      it 'is a remote' do
+        expect(remote).to be_a Remote
+      end
+
+      describe '#session' do
+        it 'raises an error to prevent real session usage' do
+          expect { remote.session }.to raise_error
+        end
+      end
+
+      describe '#execute' do
+        context 'dummy echo command' do
+          let(:command) { 'echo some arguments' }
+
+          it 'returns command arguments' do
+            expect(remote.execute(command)).to eq 'some arguments'
+          end
+        end
+
+        context 'dummy true command' do
+          let(:command) { 'true' }
+
+          it 'returns an empty string' do
+            expect(remote.execute(command)).to eq ''
+          end
+        end
+
+        context 'dummy false command' do
+          let(:command) { 'false' }
+
+          it 'raises a RemoteCommandExecutionError' do
+            expect { remote.execute(command) }.to raise_error(RemoteCommandExecutionError)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/producer/core/tests/file_contains_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+module Producer::Core
+  module Tests
+    describe FileContains, :env do
+      let(:filepath)  { 'some_file' }
+      let(:content)   { 'some_content' }
+      subject(:test)  { FileContains.new(env, filepath, content) }
+
+      it_behaves_like 'test'
+
+      describe '#verify' do
+        context 'when file contains the content' do
+          before do
+            allow(remote_fs)
+              .to receive(:file_read).with(filepath) { "foo#{content}bar" }
+          end
+
+          it 'returns true' do
+            expect(test.verify).to be true
+          end
+        end
+
+        context 'when file does not contain the content' do
+          before do
+            allow(remote_fs).to receive(:file_read).with(filepath) { 'foo bar' }
+          end
+
+          it 'returns false' do
+            expect(test.verify).to be false
+          end
+        end
+
+        context 'when file does not exist' do
+          before do
+            allow(remote_fs).to receive(:file_read).with(filepath) { nil }
+          end
+
+          it 'returns false' do
+            expect(test.verify).to be false
+          end
+        end
+      end
+    end
+  end
+end