producer-core 0.5.8 → 0.5.9

data/spec/producer/core/task_spec.rb

@@ -1,198 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  describe Task do
-    class SomeAction < Action; end
-
-    let(:env)       { Env.new }
-    let(:name)      { :some_task }
-    let(:condition) { :some_condition }
-    subject(:task)  { described_class.new(env, name, [], condition) }
-
-    %w[
-      echo
-      sh
-      mkdir
-      file_append
-      file_replace_content
-      file_write
-    ].each do |action|
-      it "has `#{action}' action defined" do
-        expect(task).to respond_to action.to_sym
-      end
-    end
-
-    describe '.define_action' do
-      before { described_class.define_action(:some_action, SomeAction) }
-
-      it 'defines a new action keyword' do
-        expect(task).to respond_to :some_action
-      end
-
-      context 'when an action keyword is called' do
-        it 'registers the action' do
-          expect { task.some_action }.to change { task.actions.count }.by 1
-        end
-
-        it 'registers the action with current env' do
-          task.some_action
-          expect(task.actions.first.env).to be env
-        end
-
-        it 'registers the action with given arguments' do
-          task.some_action :foo, :bar
-          expect(task.actions.first.arguments).to eq %i[foo bar]
-        end
-      end
-    end
-
-    describe '.evaluate' do
-      let(:code)      { proc { condition { :condition }; some_action } }
-      let(:arguments) { [] }
-      subject(:task)  { described_class.evaluate(env, name, *arguments, &code) }
-
-      before { described_class.define_action(:some_action, SomeAction) }
-
-      it 'returns an evaluated task' do
-        expect(task).to be_a Task
-      end
-
-      it 'evaluates the task condition' do
-        expect(task.condition).to be_a Condition
-      end
-
-      it 'evaluates the task actions' do
-        expect(task.actions).to match [
-          an_instance_of(SomeAction)
-        ]
-      end
-
-      context 'when task arguments are given' do
-        let(:code)      { proc { |a, b| throw a } }
-        let(:arguments) { %i[foo bar] }
-
-        it 'passes arguments as block parameters during evaluation' do
-          expect { task }.to throw_symbol :foo
-        end
-      end
-    end
-
-    describe '#initialize' do
-      subject(:task) { described_class.new(env, name) }
-
-      it 'assigns no action' do
-        expect(task.actions).to be_empty
-      end
-
-      it 'assigns a truthy condition' do
-        expect(task.condition).to be_truthy
-      end
-    end
-
-    describe '#to_s' do
-      it 'includes the task name' do
-        expect(task.to_s).to include name.to_s
-      end
-    end
-
-    describe '#condition_met?' do
-      context 'when condition is truthy' do
-        let(:condition) { true }
-
-        it 'returns true' do
-          expect(task.condition_met?).to be true
-        end
-      end
-
-      context 'when condition is falsy' do
-        let(:condition) { false }
-
-        it 'returns false' do
-          expect(task.condition_met?).to be false
-        end
-      end
-    end
-
-    describe '#condition' do
-      it 'returns current condition' do
-        expect(task.condition).to eq :some_condition
-      end
-
-      context 'when a block is given' do
-        it 'assigns a new evaluated condition' do
-          task.condition { :some_new_condition }
-          expect(task.condition.return_value).to eq :some_new_condition
-        end
-      end
-    end
-
-    describe '#task' do
-      before { described_class.define_action(:some_action, SomeAction) }
-
-      it 'registers a nested task as an action' do
-        task.task(:nested_task) { some_action }
-        expect(task.actions).to match [an_instance_of(Task)]
-      end
-    end
-
-    describe '#ask' do
-      let(:question)  { 'Which letter?' }
-      let(:choices)   { [[:a, ?A], [:b, ?B]] }
-      let(:prompter)  { instance_spy Prompter }
-      subject(:ask)   { task.ask question, choices, prompter: prompter }
-
-      it 'prompts for choices' do
-        ask
-        expect(prompter).to have_received(:prompt).with(question, choices)
-      end
-
-      it 'returns selected choice' do
-        allow(prompter).to receive(:prompt) { :choice }
-        expect(ask).to eq :choice
-      end
-    end
-
-    describe '#set' do
-      it 'sets a value in the registry' do
-        task.set :some_key, :some_value
-        expect(task.get :some_key).to eq :some_value
-      end
-    end
-
-    describe '#get' do
-      before { env[:some_key] = :some_value }
-
-      it 'fetches a value from the registry at given index' do
-        expect(task.get :some_key).to eq :some_value
-      end
-    end
-
-    describe '#set?' do
-      before { env[:some_key] = :some_value }
-
-      it 'returns true when given key exists' do
-        expect(task.set? :some_key).to be true
-      end
-
-      it 'returns false when given key does not exist' do
-        expect(task.set? :other_key).to be false
-      end
-    end
-
-    describe '#target' do
-      before { env.target = :some_target }
-
-      it 'returns current env target' do
-        expect(task.target).to eq :some_target
-      end
-    end
-
-    describe '#recipe_argv' do
-      before { env.recipe_argv = %w[foo bar] }
-
-      it 'returns recipe arguments' do
-        expect(task.recipe_argv).to eq %w[foo bar]
-      end
-    end
-  end
-end

data/spec/producer/core/template_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  describe Template do
-    include FixturesHelpers
-
-    let(:path)          { 'basic' }
-    let(:search_path)   { fixture_path_for 'templates' }
-    subject(:template)  { described_class.new path, search_path: search_path }
-
-    describe '#render' do
-      it 'renders ERB templates' do
-        expect(template.render).to eq "basic template\n"
-      end
-
-      context 'yaml templates' do
-        let(:path) { 'basic_yaml' }
-
-        it 'renders yaml templates' do
-          expect(template.render).to eq({ 'foo' => 'bar' })
-        end
-      end
-
-      context 'when variables are given' do
-        let(:path) { 'variables' }
-
-        it 'declares given variables in ERB render binding' do
-          expect(template.render foo: 'bar').to eq "bar\n"
-        end
-      end
-
-      context 'when relative path is requested' do
-        let(:path) { fixture_path_for('templates/basic').insert 0, './' }
-
-        it 'does not enforce `template\' search path' do
-          expect(template.render).to eq "basic template\n"
-        end
-      end
-    end
-  end
-end

data/spec/producer/core/test_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  describe Test do
-    it_behaves_like 'test'
-  end
-end

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

@@ -1,66 +0,0 @@
-require 'spec_helper'
-require 'producer/core/testing'
-
-module Producer::Core
-  module Testing
-    describe MockRemote do
-      subject(:remote) { described_class.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 RuntimeError
-        end
-      end
-
-      describe '#execute' do
-        context 'dummy echo command' do
-          let(:command) { 'echo some arguments' }
-
-          it 'returns command arguments ended by a record separator' do
-            expect(remote.execute command).to eq "some arguments\n"
-          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
-
-        context 'dummy type command' do
-          context 'executable exists' do
-            let(:command) { 'type true' }
-
-            it 'returns an empty string' do
-              expect(remote.execute(command)).to eq ''
-            end
-          end
-
-          context 'executable does not exist' do
-            let(:command) { 'type some_non_existent_executable' }
-
-            it 'raises a RemoteCommandExecutionError' do
-              expect { remote.execute(command) }
-                .to raise_error RemoteCommandExecutionError
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,55 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  module Tests
-    describe ConditionTest do
-      let(:env)       { double 'env' }
-      let(:block)     { proc { true } }
-      let(:arguments) { [:some, :args] }
-      subject(:test)  { described_class.new(env, block, *arguments) }
-
-      it_behaves_like 'test'
-
-      describe '#verify' do
-        context 'when condition is met' do
-          it 'returns true' do
-            expect(test.verify).to be true
-          end
-        end
-
-        context 'when condition is not met' do
-          let(:block) { proc { false } }
-
-          it 'returns false' do
-            expect(test.verify).to be false
-          end
-        end
-      end
-
-      describe '#condition' do
-        it 'evaluates a conditon' do
-          expect(Condition).to receive(:evaluate).with(env, *arguments, &block)
-          test.condition
-        end
-
-        it 'returns the evaluated condition' do
-          condition = double 'condition'
-          allow(Condition).to receive(:evaluate) { condition }
-          expect(test.condition).to eq condition
-        end
-      end
-
-      describe '#condition_args' do
-        it 'returns arguments for condition' do
-          expect(test.condition_args).to eq arguments
-        end
-      end
-
-      describe '#condition_block' do
-        it 'returns condition block' do
-          expect(test.condition_block).to eq block
-        end
-      end
-    end
-  end
-end

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

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  module Tests
-    describe FileContains, :env do
-      let(:filepath)  { 'some_file' }
-      let(:content)   { 'some_content' }
-      subject(:test)  { described_class.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

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

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  module Tests
-    describe FileEq, :env do
-      let(:filepath)  { 'some_file' }
-      let(:content)   { 'some content' }
-      subject(:test)  { described_class.new(env, filepath, content) }
-
-      it_behaves_like 'test'
-
-      describe '#verify' do
-        context 'when file content matches' do
-          before do
-            allow(remote_fs).to receive(:file_read).with(filepath) { content }
-          end
-
-          it 'returns true' do
-            expect(test.verify).to be true
-          end
-        end
-
-        context 'when file content does not match' 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

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

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  module Tests
-    describe FileMatch, :env do
-      let(:filepath)  { 'some_file' }
-      let(:pattern)   { /\Asome_content\z/ }
-      subject(:test)  { described_class.new(env, filepath, pattern) }
-
-      it_behaves_like 'test'
-
-      describe '#verify' do
-        context 'when file matches the pattern' do
-          before do
-            allow(remote_fs)
-              .to receive(:file_read).with(filepath) { 'some_content' }
-          end
-
-          it 'returns true' do
-            expect(test.verify).to be true
-          end
-        end
-
-        context 'when file does not match the pattern' 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

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

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  module Tests
-    describe HasDir, :env do
-      let(:path)        { 'some_directory' }
-      subject(:has_dir) { described_class.new(env, path) }
-
-      it_behaves_like 'test'
-
-      describe '#verify' do
-        it 'delegates the call on remote FS' do
-          expect(remote_fs).to receive(:dir?).with(path)
-          has_dir.verify
-        end
-
-        it 'returns the dir existence' do
-          existence = double 'existence'
-          allow(remote_fs).to receive(:dir?) { existence }
-          expect(has_dir.verify).to be existence
-        end
-      end
-    end
-  end
-end

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

@@ -1,75 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  module Tests
-    describe HasEnv do
-      let(:env)         { Env.new }
-      let(:var_name)    { 'SOME_VAR' }
-      let(:var_value)   { 'SOME_VALUE' }
-      let(:remote_env)  { { 'SOME_VAR' => 'SOME_VALUE' } }
-      subject(:has_env) { described_class.new(env, var_name) }
-
-      it_behaves_like 'test'
-
-      before do
-        allow(env.remote).to receive(:environment) { remote_env }
-      end
-
-      context 'when only var name is provided' do
-        describe '#verify' do
-          context 'when remote environment var is defined' do
-            it 'returns true' do
-              expect(has_env.verify).to be true
-            end
-
-            context 'when var name is given as a lowercase symbol' do
-              let(:var_name) { :some_var }
-
-              it 'returns true' do
-                expect(has_env.verify).to be true
-              end
-            end
-          end
-
-          context 'when remote environment var is not defined' do
-            let(:var_name) { 'SOME_NON_EXISTENT_VAR' }
-
-            it 'returns false' do
-              expect(has_env.verify).to be false
-            end
-          end
-        end
-      end
-
-      context 'when var name and value are provided' do
-        subject(:has_env) { described_class.new(env, var_name, var_value) }
-
-        describe '#verify' do
-          context 'when remote environment var is defined' do
-            context 'when value is the same' do
-              it 'returns true' do
-                expect(has_env.verify).to be true
-              end
-            end
-
-            context 'when value differs' do
-              let(:remote_env) { { 'SOME_VAR' => 'SOME_OTHER_VALUE' } }
-
-              it 'return false' do
-                expect(has_env.verify).to be false
-              end
-            end
-          end
-
-          context 'when remote environment var is not defined' do
-            let(:var_name) { 'SOME_NON_EXISTENT_VAR' }
-
-            it 'return false' do
-              expect(has_env.verify).to be false
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  module Tests
-    describe HasExecutable, :env do
-      subject(:test) { described_class.new(env, executable) }
-
-      it_behaves_like 'test'
-
-      describe '#verify' do
-        context 'executable exists' do
-          let(:executable) { 'true' }
-
-          it 'returns true' do
-            expect(test.verify).to be true
-          end
-        end
-
-        context 'executable does not exist' do
-          let(:executable) { 'some_non_existent_executable' }
-
-          it 'returns false' do
-            expect(test.verify).to be false
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  module Tests
-    describe HasFile, :env do
-      let(:filepath)      { 'some_file' }
-      subject(:has_file)  { described_class.new(env, filepath) }
-
-      it_behaves_like 'test'
-
-      describe '#verify' do
-        it 'delegates the call on remote FS' do
-          expect(remote_fs).to receive(:file?).with(filepath)
-          has_file.verify
-        end
-
-        it 'returns the file existence' do
-          existence = double 'existence'
-          allow(remote_fs).to receive(:file?) { existence }
-          expect(has_file.verify).to be existence
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  module Tests
-    describe ShellCommandStatus, :env do
-      let(:command)   { 'true' }
-      subject(:test)  { described_class.new(env, command) }
-
-      it_behaves_like 'test'
-
-      describe '#verify' do
-        context 'command return status is 0' do
-          it 'returns true' do
-            expect(test.verify).to be true
-          end
-        end
-
-        context 'command return status is not 0' do
-          let(:command) { 'false' }
-
-          it 'returns false' do
-            expect(test.verify).to be false
-          end
-        end
-      end
-
-      describe '#command' do
-        it 'returns the first argument' do
-          expect(test.command).to eq command
-        end
-      end
-    end
-  end
-end