producer-core 0.5.8 → 0.5.9

data/spec/producer/core/prompter_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  describe Prompter do
-    let(:input)         { StringIO.new }
-    let(:output)        { StringIO.new }
-    subject(:prompter)  { described_class.new(input, output) }
-
-    describe '#initialize' do
-      it 'assigns the given input' do
-        expect(prompter.input).to be input
-      end
-
-      it 'assigns the given output' do
-        expect(prompter.output).to be output
-      end
-    end
-
-    describe '#prompt' do
-      let(:question)  { 'Which letter?' }
-      let(:choices)   { [[:a, ?A], [:b, ?B]] }
-
-      it 'prompts choices' do
-        prompter.prompt question, choices
-        expect(output.string).to eq <<-eoh.gsub /^\s+\|/, ''
-          |#{question}
-          |0: A
-          |1: B
-          |Choice:
-        eoh
-      end
-
-      it 'returns value for entry chosen by user' do
-        input.puts '1'
-        input.rewind
-        expect(prompter.prompt question, choices).to eq :b
-      end
-    end
-  end
-end

data/spec/producer/core/recipe/file_evaluator_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  class Recipe
-    describe FileEvaluator do
-      include FixturesHelpers
-
-      describe '.evaluate' do
-        let(:env)         { Env.new }
-        let(:file_path)   { fixture_path_for 'recipes/some_recipe.rb' }
-        subject(:recipe)  { described_class.evaluate(file_path, env) }
-
-        it 'returns an evaluated recipe' do
-          expect(recipe.tasks).to match [
-            an_object_having_attributes(name: :some_task),
-            an_object_having_attributes(name: :another_task)
-          ]
-        end
-      end
-    end
-  end
-end

data/spec/producer/core/recipe_spec.rb

@@ -1,126 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  describe Recipe do
-    include FixturesHelpers
-
-    let(:env)         { Env.new }
-    subject(:recipe)  { described_class.new(env) }
-
-    describe '#initialize' do
-      it 'assigns no task' do
-        expect(recipe.tasks).to be_empty
-      end
-    end
-
-    describe '#source' do
-      let(:filepath) { fixture_path_for 'recipes/throw' }
-
-      it 'sources the recipe given as argument' do
-        expect { recipe.source filepath }.to throw_symbol :recipe_code
-      end
-    end
-
-    describe '#target' do
-      let(:host) { 'some_host.example' }
-
-      context 'when env has no assigned target' do
-        it 'registers the target host in the env' do
-          recipe.target host
-          expect(env.target).to eq host
-        end
-      end
-
-      context 'when env has an assigned target' do
-        before { env.target = 'already_assigned_host.example' }
-
-        it 'does not change env target' do
-          expect { recipe.target host }.not_to change { env.target }
-        end
-      end
-
-      context 'when no arguments are provided' do
-        it 'returns current target' do
-          recipe.target host
-          expect(recipe.target).to eq host
-        end
-      end
-    end
-
-    describe '#task' do
-      it 'registers a new evaluated task' do
-        expect { recipe.task(:some_task) { :some_task_code } }
-          .to change { recipe.tasks.count }.by 1
-      end
-
-      it 'returns the task' do
-        expect(recipe.task(:some_task) { }).to be_a Task
-      end
-    end
-
-    describe '#macro' do
-      it 'defines the new recipe keyword' do
-        recipe.macro(:hello) { }
-        expect(recipe).to respond_to(:hello)
-      end
-
-      it 'defines the new task keyword' do
-        recipe.macro(:hello) { }
-        expect { recipe.task(:some_task) { hello } }.not_to raise_error
-      end
-
-      context 'when a defined macro is called' do
-        before { recipe.macro(:hello) { :some_macro_code } }
-
-        it 'registers the new task' do
-          expect { recipe.hello }.to change { recipe.tasks.count }.by 1
-        end
-      end
-
-      context 'when a defined macro is called with arguments' do
-        before { recipe.macro(:hello) { |a, b| echo a, b } }
-
-        it 'evaluates task code with given arguments' do
-          recipe.hello :foo, :bar
-          expect(recipe.tasks.first.actions.first.arguments).to eq %i[foo bar]
-        end
-      end
-    end
-
-    describe '#compose_macro' do
-      before do
-        recipe.macro(:hello) { }
-        recipe.compose_macro :hello_composed, :some_arg
-      end
-
-      it 'defines the new recipe keyword' do
-        expect(recipe).to respond_to(:hello_composed)
-      end
-
-      it 'defines the new task keyword' do
-        expect(recipe.task(:some_task) { }).to respond_to(:hello_composed)
-      end
-    end
-
-    describe '#test_macro' do
-      it 'defines the new test' do
-        recipe.test_macro(:some_test) { }
-        expect(Condition.new).to respond_to :some_test
-      end
-    end
-
-    describe '#set' do
-      it 'registers a key/value pair in env registry' do
-        recipe.set :some_key, :some_value
-        expect(env[:some_key]).to eq :some_value
-      end
-    end
-
-    describe '#get' do
-      it 'fetches a value from the registry at given index' do
-        recipe.set :some_key, :some_value
-        expect(recipe.get :some_key).to eq :some_value
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  class Remote
-    describe Environment do
-      let(:string)          { "FOO=bar\nBAZ=qux" }
-      let(:argument)        { variables }
-
-      describe '.string_to_hash' do
-        it 'converts key=value pairs separated by new lines to a hash' do
-          expect(described_class.string_to_hash(string)).to eq ({
-            'FOO' => 'bar',
-            'BAZ' => 'qux'
-          })
-        end
-      end
-    end
-  end
-end

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

@@ -1,144 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  class Remote
-    describe FS do
-      let(:sftp_file) { double 'sftp_file' }
-      let(:sftp)      { double('sftp', file: sftp_file) }
-      subject(:fs)    { described_class.new(sftp) }
-
-      describe '#initialize' do
-        it 'assigns the sftp session' do
-          expect(fs.sftp).to be sftp
-        end
-      end
-
-      describe '#dir?' do
-        let(:path)  { 'some_directory_path' }
-        let(:stat)  { double 'stat' }
-
-        before { allow(sftp).to receive(:stat!).with(path) { stat } }
-
-        context 'when path given as argument is a directory' do
-          before { allow(stat).to receive(:directory?) { true } }
-
-          it 'returns true' do
-            expect(fs.dir? path).to be true
-          end
-        end
-
-        context 'when path given as argument is not a directory' do
-          before { allow(stat).to receive(:directory?) { false } }
-
-          it 'returns false' do
-            expect(fs.dir? path).to be false
-          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(sftp).to receive(:stat!).with(path).and_raise(ex)
-          end
-
-          it 'returns false' do
-            expect(fs.dir? path).to be false
-          end
-        end
-      end
-
-      describe '#file?' do
-        let(:file_path) { 'some_file_path' }
-        let(:stat)      { double 'stat' }
-
-        before { allow(sftp).to receive(:stat!) { stat } }
-
-        context 'when path given as argument exists' do
-          context 'when path is a file' do
-            before { allow(stat).to receive(:file?) { true } }
-
-            it 'returns true' do
-              expect(fs.file? file_path).to be true
-            end
-          end
-
-          context 'when path is not a file' do
-            before { allow(stat).to receive(:file?) { false } }
-
-            it 'returns false' do
-              expect(fs.file? file_path).to be false
-            end
-          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
-
-          it 'returns false' do
-            expect(fs.file? file_path).to be false
-          end
-        end
-      end
-
-      describe '#mkdir' do
-        let(:path)        { 'some_directory_path' }
-        let(:attributes)  { { foo: :bar } }
-
-        it 'creates the directory' do
-          expect(sftp).to receive(:mkdir!).with(path, attributes)
-          fs.mkdir path, attributes
-        end
-      end
-
-      describe '#file_read' do
-        let(:f)       { double 'f' }
-        let(:path)    { 'some_file_path' }
-        let(:content) { 'some_content' }
-
-        before do
-          allow(sftp_file).to receive(:open).and_yield(f)
-          allow(f).to receive(:read) { content }
-        end
-
-        it 'returns the file content' do
-          expect(fs.file_read(path)).to eq content
-        end
-
-        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
-
-          it 'returns nil' do
-            expect(fs.file_read(path)).to be nil
-          end
-        end
-      end
-
-      describe '#file_write' do
-        let(:path)    { 'some_file_path' }
-        let(:content) { 'some_content' }
-
-        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
-      end
-    end
-  end
-end

data/spec/producer/core/remote_spec.rb

@@ -1,168 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  describe Remote do
-    let(:hostname)    { 'some_host.example' }
-    subject(:remote)  { described_class.new(hostname) }
-
-    describe '#initialize' do
-      it 'assigns the given hostname' do
-        expect(remote.hostname).to eq hostname
-      end
-    end
-
-    describe '#session' do
-      it 'builds a new SSH session to the remote host with #user_name' do
-        expect(Net::SSH).to receive(:start).with(hostname, remote.user_name)
-        remote.session
-      end
-
-      it 'returns the session' do
-        session = double('SSH session')
-        allow(Net::SSH).to receive(:start) { session }
-        expect(remote.session).to eq session
-      end
-
-      it 'memoizes the session' do
-        allow(Net::SSH).to receive(:start) { Object.new }
-        expect(remote.session).to be remote.session
-      end
-
-      context 'when hostname is invalid' do
-        let(:hostname) { nil }
-
-        it 'raises RemoteInvalidError' do
-          expect { remote.session }.to raise_error RemoteInvalidError
-        end
-      end
-    end
-
-    describe '#config' do
-      it 'builds a config for current host name' do
-        expect(Net::SSH::Config).to receive(:for).with(hostname)
-        remote.config
-      end
-
-      it 'returns the config' do
-        ssh_config = double('ssh config')
-        allow(Net::SSH::Config).to receive(:for) { ssh_config }
-        expect(remote.config).to be ssh_config
-      end
-
-      it 'memoizes the config' do
-        allow(Net::SSH::Config).to receive(:for) { Object.new }
-        expect(remote.config).to be remote.config
-      end
-    end
-
-    describe '#user_name' do
-      context 'ssh config has an entry for user' do
-        let(:config_user_name) { 'my_user_name' }
-
-        before do
-          allow(Net::SSH::Config).to receive(:for) { { user: config_user_name } }
-        end
-
-        it 'returns the configured value' do
-          expect(remote.user_name).to eq config_user_name
-        end
-      end
-
-      context 'ssh config has no entry for user' do
-        it 'returns the name of the user currently logged in' do
-          expect(remote.user_name).to eq Etc.getlogin
-        end
-      end
-    end
-
-    describe '#fs' do
-      let(:sftp_session) { double 'sftp session' }
-
-      it 'returns an FS instance built with a new sftp session' do
-        allow(remote)
-          .to receive_message_chain(:session, :sftp, :connect) { sftp_session }
-        expect(remote.fs.sftp).to be sftp_session
-      end
-    end
-
-    describe '#execute', :ssh do
-      let(:arguments) { 'some remote command' }
-      let(:command)   { "echo #{arguments}" }
-      let(:output)    { StringIO.new }
-
-      it 'executes the given command in a new channel' do
-        story_with_new_channel do |ch|
-          ch.sends_exec command
-          ch.gets_data arguments
-        end
-        expect_story_completed { remote.execute command }
-      end
-
-      it 'returns the command standard output output' do
-        story_with_new_channel do |ch|
-          ch.sends_exec command
-          ch.gets_data arguments
-        end
-        expect(remote.execute command).to eq arguments
-      end
-
-      it 'writes command standard output to provided output' do
-        story_with_new_channel do |ch|
-          ch.sends_exec command
-          ch.gets_data arguments
-        end
-        remote.execute command, output
-        expect(output.string).to eq arguments
-      end
-
-      it 'writes command error output to provided error output' do
-        error_output = StringIO.new
-        story_with_new_channel do |ch|
-          ch.sends_exec command
-          ch.gets_extended_data arguments
-        end
-        remote.execute command, output, error_output
-        expect(error_output.string).to eq arguments
-      end
-
-      context 'when command execution fails' do
-        before do
-          story_with_new_channel do |ch|
-            ch.sends_exec command
-            ch.gets_data arguments
-            ch.gets_exit_status 1
-          end
-        end
-
-        it 'raises an exception' do
-          expect { remote.execute command }
-            .to raise_error RemoteCommandExecutionError
-        end
-
-        it 'includes the command in the exception message' do
-          expect { remote.execute command }.to raise_error /#{command}/
-        end
-      end
-    end
-
-    describe '#environment' do
-      let(:command) { 'env' }
-      let(:output)  { 'FOO=bar' }
-
-      before { allow(remote).to receive(:execute) { output } }
-
-      it 'returns a remote environment' do
-        expect(remote.environment['FOO']).to eq 'bar'
-      end
-    end
-
-    describe '#cleanup' do
-      before { remote.session = double 'session' }
-
-      it 'closes the session' do
-        expect(remote.session).to receive :close
-        remote.cleanup
-      end
-    end
-  end
-end