producer-core 0.5.8 → 0.5.9

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

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  module Tests
-    describe YAMLEq, :env do
-      let(:filepath)  { 'some_file' }
-      let(:data)      { { foo: 'bar' } }
-      subject(:test)  { described_class.new(env, filepath, data, {}) }
-
-      it_behaves_like 'test'
-
-      describe '#verify' do
-        context 'when file content matches' do
-          before do
-            allow(remote_fs)
-              .to receive(:file_read).with(filepath) { ':foo: bar' }
-          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: baz' }
-          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/worker_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  describe Worker do
-    let(:env)         { Env.new }
-    subject(:worker)  { described_class.new(env) }
-
-    describe '#process' do
-      it 'processes each task' do
-        expect(worker).to receive(:process_task).with(:some_task)
-        worker.process [:some_task]
-      end
-
-      context 'when dry run is enabled' do
-        before { env.dry_run = true }
-
-        it 'warns dry run is enabled' do
-          expect(env).to receive(:log).with(
-            /\Arunning in dry run mode, actions will NOT be applied\z/,
-            :warn
-          )
-          worker.process []
-        end
-      end
-    end
-
-    describe '#process_task' do
-      let(:env)     { instance_spy Env, dry_run?: false }
-      let(:action)  { double('action', to_s: 'echo').as_null_object }
-      let(:task)    { Task.new(env, :some_task, [action]) }
-
-      it 'logs task info' do
-        expect(env).to receive(:log).with /\ATask: `some_task'/
-        worker.process_task task
-      end
-
-      context 'when task condition is met' do
-        it 'applies the actions' do
-          expect(action).to receive :apply
-          worker.process_task task
-        end
-
-        it 'logs the task as beeing applied' do
-          expect(env).to receive(:log).with /some_task.+applying\.\.\.\z/
-          worker.process_task task
-        end
-
-        it 'logs action info' do
-          expect(env).to receive(:log).with /\A action: echo/
-          worker.process_task task
-        end
-
-        context 'when dry run is enabled' do
-          before { allow(env).to receive(:dry_run?) { true } }
-
-          it 'does not apply the actions' do
-            expect(action).not_to receive :apply
-            worker.process_task task
-          end
-        end
-      end
-
-      context 'when task condition is not met' do
-        before { task.condition { false } }
-
-        it 'does not apply the actions' do
-          expect(action).not_to receive :apply
-          worker.process_task task
-        end
-
-        it 'logs the task as being skipped' do
-          expect(env).to receive(:log).with /some_task.+skipped\z/
-          worker.process_task task
-        end
-      end
-
-      context 'when a task contains nested tasks' do
-        let(:inner_task)  { Task.new(env, :inner, [action]) }
-        let(:outer_task)  { Task.new(env, :outer, [inner_task]) }
-
-        it 'processes nested tasks' do
-          expect(action).to receive :apply
-          worker.process [outer_task]
-        end
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,13 +0,0 @@
-require 'producer/core'
-
-Dir['spec/support/**/*.rb'].map { |e| require e.gsub 'spec/', '' }
-
-
-RSpec.configure do |c|
-  c.include TestEnvHelpers, :env
-
-  c.include NetSSHStoryHelpers, :ssh
-  c.before(:each, :ssh) do
-    allow(Net::SSH).to receive(:start) { connection }
-  end
-end

data/spec/support/exit_helpers.rb

@@ -1,6 +0,0 @@
-module ExitHelpers
-  def trap_exit
-    yield
-  rescue SystemExit
-  end
-end

data/spec/support/fixtures_helpers.rb

@@ -1,7 +0,0 @@
-module FixturesHelpers
-  FIXTURES_PATH = 'spec/fixtures'
-
-  def fixture_path_for(path)
-    File.join(FIXTURES_PATH, path)
-  end
-end

data/spec/support/net_ssh_story_helpers.rb

@@ -1,36 +0,0 @@
-require 'net/ssh/test'
-
-if Net::SSH::Version::CURRENT >= Net::SSH::Version[2, 8, 0]
-  module Net
-    module SSH
-      module Test
-        class Socket
-          def open(host, port, connections_options = nil)
-            @host, @port = host, port
-            self
-          end
-        end
-      end
-    end
-  end
-end
-
-module NetSSHStoryHelpers
-  include Net::SSH::Test
-
-  def story_with_new_channel
-    story do |session|
-      ch = session.opens_channel
-      yield ch
-      ch.gets_close
-      ch.sends_close
-    end
-  end
-
-  def expect_story_completed
-    raise 'there is no story to expect' if socket.script.events.empty?
-    yield
-    expect(socket.script.events)
-      .to be_empty, "#{socket.script.events.count} story events still pending"
-  end
-end

data/spec/support/shared_action.rb

@@ -1,44 +0,0 @@
-module Producer::Core
-  shared_examples 'action' do
-    include TestEnvHelpers
-
-    let(:options)     { { foo: :bar } }
-    subject(:action)  { described_class.new(env, *arguments, options) }
-
-    describe '#input' do
-      it 'returns env input' do
-        expect(action.input).to be env.input
-      end
-    end
-
-    describe '#output' do
-      it 'returns env output' do
-        expect(action.output).to be env.output
-      end
-    end
-
-    describe '#error_output' do
-      it 'returns env error output' do
-        expect(action.error_output).to be env.error_output
-      end
-    end
-
-    describe '#remote' do
-      it 'returns env remote' do
-        expect(action.remote).to be env.remote
-      end
-    end
-
-    describe '#fs' do
-      it 'returns env remote fs' do
-        expect(action.fs).to be env.remote.fs
-      end
-    end
-
-    describe '#name' do
-      it 'returns a word' do
-        expect(action.name).to match /\A\w+\z/
-      end
-    end
-  end
-end

data/spec/support/shared_test.rb

@@ -1,82 +0,0 @@
-module Producer::Core
-  shared_examples 'test' do
-    include TestEnvHelpers
-
-    let(:arguments)   { [:some, :arguments] }
-    subject(:test)    { described_class.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).not_to 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
-  end
-end

data/spec/support/test_env_helpers.rb

@@ -1,44 +0,0 @@
-module TestEnvHelpers
-  require 'producer/core/testing'
-
-  def env
-    @_env ||= build_env
-  end
-
-  def output
-    env.output.string
-  end
-
-  def error_output
-    env.error_output.string
-  end
-
-  def remote_fs
-    env.remote.fs
-  end
-
-  def expect_execution(command)
-    opts = { expected_from: caller.first }
-    RSpec::Mocks
-      .expect_message(env.remote, :execute, opts)
-      .with(command, env.output, env.error_output)
-  end
-
-
-  private
-
-  def build_env
-    Producer::Core::Env.new(
-      output:       StringIO.new,
-      error_output: StringIO.new,
-      remote:       build_remote
-    )
-  end
-
-  def build_remote
-    fs = instance_spy Producer::Core::Remote::FS
-    remote = Producer::Core::Testing::MockRemote.new('some_host.test')
-    remote.define_singleton_method(:fs) { fs }
-    remote
-  end
-end