producer-core 0.5.8 → 0.5.9

data/spec/producer/core/cli_spec.rb

@@ -1,211 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  describe CLI do
-    include ExitHelpers
-    include FixturesHelpers
-
-    let(:options)     { [] }
-    let(:recipe_file) { fixture_path_for 'recipes/some_recipe.rb' }
-    let(:arguments)   { [*options, recipe_file] }
-    let(:environment) { {} }
-
-    subject(:cli)     { described_class.new(arguments, environment) }
-
-    describe '.run!' do
-      subject(:run!) { described_class.run! arguments }
-
-      it 'builds a new CLI instance with given arguments and environment' do
-        expect(described_class)
-          .to receive(:new).with(arguments, ENV, anything).and_call_original
-        run!
-      end
-
-      it 'parses new CLI instance arguments' do
-        expect_any_instance_of(described_class).to receive :parse_arguments!
-        run!
-      end
-
-      it 'runs the new CLI instance' do
-        expect_any_instance_of(described_class).to receive :run
-        run!
-      end
-
-      context 'when no recipe is given' do
-        let(:arguments) { [] }
-
-        it 'exits with a return status of 64' do
-          expect { described_class.run! arguments, stderr: StringIO.new }
-            .to raise_error(SystemExit) { |e| expect(e.status).to eq 64 }
-        end
-
-        it 'prints the usage on the error stream' do
-          expect { trap_exit { run! } }
-            .to output(/\AUsage: .+/).to_stderr
-        end
-      end
-
-      context 'when an error is raised' do
-        let(:recipe_file) { fixture_path_for 'recipes/raise.rb' }
-
-        it 'exits with a return status of 70' do
-          expect { described_class.run! arguments, stderr: StringIO.new }
-            .to raise_error(SystemExit) { |e| expect(e.status).to eq 70 }
-        end
-
-        it 'prints a report to the error stream' do
-          expect { trap_exit { run! } }
-            .to output(/\ARecipeEvaluationError: false$/).to_stderr
-        end
-      end
-    end
-
-    describe '#initialize' do
-      it 'assigns an env' do
-        expect(cli.env).to be_an Env
-      end
-
-      it 'assigns CLI stdin as the env input' do
-        expect(cli.env.input).to be cli.stdin
-      end
-
-      it 'assigns CLI stdout as the env output' do
-        expect(cli.env.output).to be cli.stdout
-      end
-
-      it 'assigns CLI stderr as the env error output' do
-        expect(cli.env.error_output).to be cli.stderr
-      end
-
-      context 'when PRODUCER_VERBOSE environment variable is set' do
-        before { environment['PRODUCER_VERBOSE'] = 'yes' }
-
-        it 'enables env verbose mode' do
-          expect(cli.env).to be_verbose
-        end
-      end
-
-      context 'when PRODUCER_DEBUG environment variable is set' do
-        before { environment['PRODUCER_DEBUG'] = 'yes' }
-
-        it 'enables env debug mode' do
-          expect(cli.env).to be_debug
-        end
-      end
-
-      context 'when PRODUCER_DRYRUN environment variable is set' do
-        before { environment['PRODUCER_DRYRUN'] = 'yes' }
-
-        it 'enables env dry run mode' do
-          expect(cli.env).to be_dry_run
-        end
-      end
-    end
-
-    describe '#parse_arguments!' do
-      let(:options) { %w[-v -t some_host.example] }
-
-      it 'removes options from arguments' do
-        cli.parse_arguments!
-        expect(cli.arguments).to eq [recipe_file]
-      end
-
-      context 'with verbose option' do
-        let(:options) { %w[-v] }
-
-        it 'enables env verbose mode' do
-          cli.parse_arguments!
-          expect(cli.env).to be_verbose
-        end
-      end
-
-      context 'with dry run option' do
-        let(:options) { %w[-n] }
-
-        it 'enables env dry run mode' do
-          cli.parse_arguments!
-          expect(cli.env).to be_dry_run
-        end
-      end
-
-      context 'with target option' do
-        let(:options) { %w[-t some_host.example] }
-
-        it 'assigns the given target to the env' do
-          cli.parse_arguments!
-          expect(cli.env.target).to eq 'some_host.example'
-        end
-      end
-
-      context 'with debug option' do
-        let(:options) { %w[-d] }
-
-        it 'assigns the given target to the env' do
-          cli.parse_arguments!
-          expect(cli.env).to be_debug
-        end
-      end
-
-      context 'with combined options' do
-        let(:options) { %w[-vn]}
-
-        it 'handles combined options' do
-          cli.parse_arguments!
-          expect(cli.env).to be_verbose.and be_dry_run
-        end
-      end
-
-      context 'with recipe arguments' do
-        let(:arguments) { %w[recipe.rb -- foo] }
-
-        it 'removes recipe arguments' do
-          cli.parse_arguments!
-          expect(cli.arguments).to eq %w[recipe.rb]
-        end
-
-        it 'assigns env recipe arguments' do
-          cli.parse_arguments!
-          expect(cli.env.recipe_argv).to eq %w[foo]
-        end
-      end
-
-      context 'when no arguments remains after parsing' do
-        let(:arguments) { [] }
-
-        it 'raises an error' do
-          expect { cli.parse_arguments! }
-            .to raise_error described_class::ArgumentError
-        end
-      end
-    end
-
-    describe '#run' do
-      it 'processes recipes tasks with a worker' do
-        worker = instance_spy Worker
-        cli.run worker: worker
-        expect(worker).to have_received(:process)
-          .with all be_an_instance_of Task
-      end
-
-      it 'cleans up the env' do
-        expect(cli.env).to receive :cleanup
-        cli.run
-      end
-
-      context 'on error' do
-        let(:recipe_file) { fixture_path_for 'recipes/raise.rb' }
-
-        it 'cleans up the env' do
-          expect(cli.env).to receive :cleanup
-          cli.run rescue nil
-        end
-      end
-    end
-
-    describe '#evaluate_recipes' do
-      it 'returns the evaluated recipes' do
-        expect(cli.evaluate_recipes).to all be_an_instance_of Recipe
-      end
-    end
-  end
-end

data/spec/producer/core/condition_spec.rb

@@ -1,198 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  describe Condition do
-    subject(:condition) { described_class.new }
-
-    %w[
-      `
-      sh
-      file_contains
-      file_eq
-      file_match
-      dir?
-      env?
-      executable?
-      file?
-    ].each do |test|
-      it "has `#{test}' test defined" do
-        expect(condition).to respond_to test.to_sym
-      end
-    end
-
-    describe '.define_test' do
-      let(:some_test) { Test }
-
-      before { described_class.define_test(:some_test, some_test) }
-
-      it 'defines a new test keyword' do
-        expect(condition).to respond_to :some_test
-      end
-
-      it 'defines the negated test' do
-        expect(condition).to respond_to :no_some_test
-      end
-
-      context 'when a test keyword is called' do
-        it 'registers the test' do
-          expect { condition.some_test }.to change { condition.tests.count }.by 1
-        end
-
-        it 'registers the test with assigned env' do
-          env = double 'env'
-          condition.instance_eval { @env = env }
-          condition.some_test
-          expect(condition.tests.last.env).to be env
-        end
-
-        it 'registers the test with given arguments' do
-          condition.some_test :foo, :bar
-          expect(condition.tests.last.arguments).to eq %i[foo bar]
-        end
-
-        context 'when given test is callable' do
-          let(:some_test) { proc { } }
-
-          before { condition.some_test }
-
-          it 'registers a condition test' do
-            expect(condition.tests.last).to be_a Tests::ConditionTest
-          end
-
-          it 'registers the test with given block' do
-            expect(condition.tests.last.condition_block).to be some_test
-          end
-
-          it 'registers the test with given arguments' do
-            condition.some_test :foo, :bar
-            expect(condition.tests.last.condition_args).to eq %i[foo bar]
-          end
-        end
-      end
-
-      context 'when a negated test keyword is called' do
-        it 'registers a negated test' do
-          condition.no_some_test
-          expect(condition.tests.last).to be_negated
-        end
-      end
-    end
-
-    describe '.evaluate' do
-      let(:env)           { double 'env' }
-      let(:code)          { proc { some_test; :some_return_value } }
-      let(:some_test)     { Class.new(Test) }
-      let(:arguments)     { [] }
-      subject(:condition) { described_class.evaluate(env, *arguments, &code) }
-
-      before { described_class.define_test(:some_test, some_test) }
-
-      it 'returns an evaluated condition' do
-        expect(condition).to be_a described_class
-      end
-
-      it 'evaluates the condition tests' do
-        expect(condition.tests.first).to be_a Test
-      end
-
-      it 'evaluates the condition return value' do
-        expect(condition.return_value).to eq :some_return_value
-      end
-
-      context 'when arguments are given' do
-        let(:code)      { proc { |a, b| throw a } }
-        let(:arguments) { %i[foo bar] }
-
-        it 'passes arguments as block parameters' do
-          expect { condition }
-            .to throw_symbol :foo
-        end
-      end
-    end
-
-    describe '#initialize' do
-      it 'assigns no tests' do
-        expect(condition.tests).to be_empty
-      end
-
-      it 'assigns the return value as nil' do
-        expect(condition.return_value).to be nil
-      end
-    end
-
-    describe '#met?' do
-      let(:test_ok)       { instance_spy Test, pass?: true }
-      let(:test_ko)       { instance_spy Test, pass?: false }
-      subject(:condition) { described_class.new(tests) }
-
-      context 'when all tests are successful' do
-        let(:tests) { [test_ok, test_ok] }
-
-        it 'returns true' do
-          expect(condition.met?).to be true
-        end
-      end
-
-      context 'when one test is unsuccessful' do
-        let(:tests) { [test_ok, test_ko] }
-
-        it 'returns false' do
-          expect(condition.met?).to be false
-        end
-      end
-
-      context 'when there are no test' do
-        let(:tests)         { [] }
-        subject(:condition) { described_class.new([], return_value) }
-
-        context 'and return value is truthy' do
-          let(:return_value) { :some_truthy_value }
-
-          it 'returns true' do
-            expect(condition.met?).to be true
-          end
-        end
-
-        context 'and return value is falsy' do
-          let(:return_value) { nil }
-
-          it 'returns false' do
-            expect(condition.met?).to be false
-          end
-        end
-      end
-    end
-
-    describe '#!' do
-      [true, false].each do |b|
-        context "when #met? return #{b}" do
-          before { allow(condition).to receive(:met?) { b } }
-
-          it 'returns the negated #met?' do
-            expect(condition.!).to be !condition.met?
-          end
-        end
-      end
-    end
-
-    describe '#get' do
-      let(:env) { Env.new }
-
-      it 'delegates to env registry' do
-        expect(env).to receive(:get).with :some_key
-        described_class.evaluate(env, []) { get :some_key }
-      end
-    end
-
-    describe '#target' do
-      let(:env) { Env.new }
-
-      before { env.target = :some_target }
-
-      it 'returns current env target' do
-        condition = described_class.evaluate(env, []) { target == :some_target }
-        expect(condition).to be_met
-      end
-    end
-  end
-end

data/spec/producer/core/env_spec.rb

@@ -1,196 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  describe Env do
-    let(:output)  { StringIO.new }
-    subject(:env) { described_class.new(output: output) }
-
-    describe '#initialize' do
-      it 'assigns $stdin as the default input' do
-        expect(env.input).to be $stdin
-      end
-
-      it 'assigns $stderr as the default error output' do
-        expect(env.error_output).to be $stderr
-      end
-
-      it 'assigns no default target' do
-        expect(env.target).not_to be
-      end
-
-      it 'assigns an empty registry' do
-        expect(env.registry).to be_empty
-      end
-
-      it 'assigns verbose as false' do
-        expect(env.verbose).to be false
-      end
-
-      it 'assigns debug as false' do
-        expect(env.debug).to be false
-      end
-
-      it 'assigns dry run as false' do
-        expect(env.dry_run).to be false
-      end
-
-      context 'when output is not given as argument' do
-        subject(:env) { described_class.new }
-
-        it 'assigns $stdout as the default output' do
-          expect(env.output).to be $stdout
-        end
-      end
-
-      context 'when input is given as argument' do
-        let(:input)   { double 'input' }
-        subject(:env) { described_class.new(input: input) }
-
-        it 'assigns the given input' do
-          expect(env.input).to be input
-        end
-      end
-
-      context 'when output is given as argument' do
-        subject(:env) { described_class.new(output: output) }
-
-        it 'assigns the given output' do
-          expect(env.output).to be output
-        end
-      end
-
-      context 'when error output is given as argument' do
-        let(:error_output)  { StringIO.new }
-        subject(:env)       { described_class.new(error_output: error_output) }
-
-        it 'assigns the given error output' do
-          expect(env.error_output).to be error_output
-        end
-      end
-
-      context 'when remote is given as argument' do
-        let(:remote)  { double 'remote' }
-        subject(:env) { described_class.new(remote: remote) }
-
-        it 'assigns the given remote' do
-          expect(env.remote).to be remote
-        end
-      end
-    end
-
-    describe '#target' do
-      let(:target) { double 'target' }
-
-      it 'returns the assigned target' do
-        env.target = target
-        expect(env.target).to be target
-      end
-    end
-
-    describe '#remote' do
-      it 'builds a Remote with the current target' do
-        env.target = 'some_hostname.example'
-        expect(Remote).to receive(:new).with(env.target)
-        env.remote
-      end
-
-      it 'returns the remote' do
-        remote = double 'remote'
-        allow(Remote).to receive(:new) { remote }
-        expect(env.remote).to eq remote
-      end
-
-      it 'memoizes the remote' do
-        expect(env.remote).to be env.remote
-      end
-    end
-
-    describe '#[]' do
-      subject(:env) { Env.new(registry: { some_key: :some_value }) }
-
-      it 'returns the value indexed by given key from the registry' do
-        expect(env[:some_key]).to eq :some_value
-      end
-
-      it 'raises an error when given invalid key' do
-        expect { env[:no_key] }.to raise_error RegistryKeyError
-      end
-    end
-
-    describe '#[]=' do
-      it 'registers given value at given index in the registry' do
-        env[:some_key] = :some_value
-        expect(env[:some_key]).to eq :some_value
-      end
-    end
-
-    describe '#logger' do
-      it 'returns a logger' do
-        expect(env.logger).to be_a Logger
-      end
-
-      it 'uses env output' do
-        env.logger.error 'some message'
-        expect(output.string).to include 'some message'
-      end
-
-      it 'has a log level of WARN' do
-        expect(env.logger.level).to eq Logger::WARN
-      end
-
-      it 'uses our formatter' do
-        expect(env.logger.formatter).to be_a LoggerFormatter
-      end
-
-      context 'when verbose mode is enabled' do
-        before { env.verbose = true }
-
-        it 'has a log level of INFO' do
-          expect(env.logger.level).to eq Logger::INFO
-        end
-      end
-    end
-
-    describe '#log' do
-      it 'logs an info message through the assigned logger' do
-        expect(env.logger).to receive(:info).with 'message'
-        env.log 'message'
-      end
-
-      context 'when second argument is :warn' do
-        it 'logs a warning message through the assigned logger' do
-          expect(env.logger).to receive(:warn).with 'message'
-          env.log 'message', :warn
-        end
-      end
-    end
-
-    describe '#verbose?' do
-      it 'returns true when verbose is enabled' do
-        env.verbose = true
-        expect(env).to be_verbose
-      end
-    end
-
-    describe '#debug?' do
-      it 'returns true when debug is enabled' do
-        env.debug = true
-        expect(env).to be_debug
-      end
-    end
-
-    describe '#dry_run?' do
-      it 'returns true when dry run is enabled' do
-        env.dry_run = true
-        expect(env).to be_dry_run
-      end
-    end
-
-    describe '#cleanup' do
-      it 'cleans up the remote' do
-        expect(env.remote).to receive :cleanup
-        env.cleanup
-      end
-    end
-  end
-end

data/spec/producer/core/error_formatter_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-
-module Producer
-  module Core
-    describe ErrorFormatter do
-      let(:debug)         { false }
-      let(:force_cause)   { [] }
-      let(:options)       { { debug: debug, force_cause: force_cause } }
-      subject(:formatter) { described_class.new(options) }
-
-      describe '#debug?' do
-        it 'returns false' do
-          expect(formatter.debug?).to be false
-        end
-
-        context 'when debug is enabled' do
-          let(:debug) { true }
-
-          it 'returns true' do
-            expect(formatter.debug?).to be true
-          end
-        end
-      end
-
-      describe '#format' do
-        let(:rubylibdir)  { RbConfig::CONFIG['rubylibdir'] }
-        let(:bt)          { %W[backtrace /producer /net-ssh #{rubylibdir}] }
-        let(:exception)   { RuntimeError.new('some exception').tap { |o| o.set_backtrace bt } }
-
-        def exception_with_cause
-          begin fail 'exception cause' rescue fail 'some exception' end
-        rescue => e
-          e.tap { |o| o.set_backtrace bt }
-        end
-
-        it 'formats the message' do
-          expect(formatter.format exception)
-            .to match /^RuntimeError: some exception$/
-        end
-
-        it 'indents the backtrace' do
-          expect(formatter.format exception).to match /^\s+backtrace$/
-        end
-
-        it 'excludes producer code from the backtrace' do
-          expect(formatter.format exception).not_to include 'producer'
-        end
-
-        it 'excludes net-ssh from the backtrace' do
-          expect(formatter.format exception).not_to include 'net-ssh'
-        end
-
-        it 'excludes ruby lib directory from the backtrace' do
-          expect(formatter.format exception).not_to include rubylibdir
-        end
-
-        context 'when exception has a cause' do
-          it 'does not include the cause' do
-            expect(formatter.format exception_with_cause)
-              .not_to include 'exception cause'
-          end
-        end
-
-        context 'when debug is enabled' do
-          let(:debug) { true }
-
-          it 'does not filter the backtrace' do
-            expect(formatter.format exception).to include 'producer'
-          end
-
-          context 'when exception has a cause' do
-            it 'includes the exception cause' do
-              expect(formatter.format exception_with_cause)
-                .to include 'exception cause'
-            end
-
-            it 'formats the cause' do
-              expect(formatter.format exception_with_cause)
-                .to match /^cause:\nRuntimeError: exception cause/
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/producer/core/logger_formatter_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  describe LoggerFormatter do
-    describe '#call' do
-      let(:severity)  { double 'severity' }
-      let(:datetime)  { double 'datetime' }
-      let(:progname)  { double 'progname' }
-      let(:message)   { 'some message' }
-
-      subject { described_class.new.call(severity, datetime, progname, message) }
-
-      it 'returns the given message with a line separator' do
-        expect(subject).to eq "#{message}\n"
-      end
-
-      context 'when severity is WARN' do
-        let(:severity) { 'WARN' }
-
-        it 'prefix the message with `Warning:\'' do
-          expect(subject).to match /\AWarning: #{message}/
-        end
-      end
-    end
-  end
-end