producer-core 0.2.5 → 0.2.6

data/lib/producer/core/version.rb

@@ -1,5 +1,5 @@
 module Producer
   module Core
-    VERSION = '0.2.5'
+    VERSION = '0.2.6'.freeze
   end
 end

data/lib/producer/core.rb

@@ -16,6 +16,7 @@ require 'producer/core/actions/file_writer'
 
 # condition tests (need to be defined before the condition DSL)
 require 'producer/core/test'
+require 'producer/core/tests/condition_test'
 require 'producer/core/tests/file_contains'
 require 'producer/core/tests/has_dir'
 require 'producer/core/tests/has_env'

data/spec/producer/core/cli_spec.rb

@@ -8,64 +8,89 @@ module Producer::Core
     let(:recipe_file) { fixture_path_for 'recipes/some_recipe.rb' }
     let(:options)     { [] }
     let(:arguments)   { [*options, recipe_file] }
+    let(:stdin)       { StringIO.new}
     let(:stdout)      { StringIO.new }
+    let(:stderr)      { StringIO.new }
 
-    subject(:cli)     { CLI.new(arguments, stdout: stdout) }
+    subject(:cli)     { CLI.new(arguments, stdin: stdin, stdout: stdout) }
 
     describe '.run!' do
-      let(:cli)       { double('cli').as_null_object }
-      let(:output)    { StringIO.new }
-      subject(:run)   { described_class.run! arguments, output: output }
+      let(:cli) { double('cli').as_null_object }
 
-      it 'builds a new CLI with given arguments' do
-        expect(described_class)
-          .to receive(:new).with(arguments).and_call_original
+      subject(:run) do
+        described_class.run! arguments,
+          stdin:  stdin,
+          stdout: stdout,
+          stderr: stderr
+      end
+
+      before { allow(described_class).to receive(:new) { cli } }
+
+      it 'builds a new CLI with given arguments and streams' do
+        expect(described_class).to receive(:new).with(arguments,
+          stdin:  stdin,
+          stdout: stdout,
+          stderr: stderr
+        )
         run
       end
 
       it 'runs the CLI' do
-        allow(described_class).to receive(:new) { cli }
         expect(cli).to receive :run
         run
       end
 
       it 'parses CLI arguments' do
-        allow(described_class).to receive(:new) { cli }
         expect(cli).to receive :parse_arguments!
         run
       end
 
       context 'when an argument error is raised' do
         before do
-          allow(described_class).to receive(:new) { cli }
           allow(cli).to receive(:parse_arguments!)
             .and_raise described_class::ArgumentError
         end
 
         it 'exits with a return status of 64' do
-          expect { run }.to raise_error(SystemExit) { |e|
+          expect { run }.to raise_error(SystemExit) do |e|
             expect(e.status).to eq 64
-          }
+          end
         end
 
-        it 'prints the usage' do
+        it 'prints the usage on the error stream' do
           trap_exit { run }
-          expect(output.string).to match /\AUsage: .+/
+          expect(stderr.string).to match /\AUsage: .+/
+        end
+      end
+
+      context 'when a runtime error is raised' do
+        before do
+          allow(cli).to receive(:run)
+            .and_raise RuntimeError, 'some message'
+        end
+
+        it 'exits with a return status of 70' do
+          expect { run }.to raise_error(SystemExit) do |e|
+            expect(e.status).to eq 70
+          end
+        end
+
+        it 'prints exception name and message and the error stream' do
+          trap_exit { run }
+          expect(stderr.string).to match /\ARuntimeError: some message/
         end
       end
     end
 
     describe '#initialize' do
-      it 'assigns the env with CLI output' do
-        expect(cli.env.output).to be stdout
-      end
+      subject(:cli) { described_class.new(arguments) }
 
-      context 'without options' do
-        subject(:cli) { described_class.new(arguments) }
+      it 'assigns $stdin as the default standard input' do
+        expect(cli.stdin).to be $stdin
+      end
 
-        it 'assigns $stdout as the default standard output' do
-          expect(cli.stdout).to be $stdout
-        end
+      it 'assigns $stdout as the default standard output' do
+        expect(cli.stdout).to be $stdout
       end
     end
 
@@ -81,6 +106,20 @@ module Producer::Core
       end
     end
 
+    describe '#env' do
+      it 'returns the assigned 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 stdin
+      end
+
+      it 'assigns CLI stdout as the env output' do
+        expect(cli.env.output).to be stdout
+      end
+    end
+
     describe '#parse_arguments!' do
       context 'with options' do
         let(:options) { %w[-v] }
@@ -92,15 +131,15 @@ module Producer::Core
         end
 
         context 'verbose' do
-          it 'sets env logger level to INFO' do
-            expect(cli.env.log_level).to eq Logger::INFO
+          it 'enables env verbose mode' do
+            expect(cli.env).to be_verbose
           end
         end
 
         context 'dry run' do
           let(:options) { %w[-n] }
 
-          it 'enables env dry run' do
+          it 'enables env dry run mode' do
             expect(cli.env).to be_dry_run
           end
         end
@@ -116,21 +155,12 @@ module Producer::Core
     end
 
     describe '#run' do
-      it 'loads the recipe' do
-        cli.run
-        expect(cli.recipe).to be_a Recipe
-      end
-
       it 'process recipe tasks with given worker' do
         worker = double 'worker'
-        expect(worker).to receive(:process).with [kind_of(Task), kind_of(Task)]
-        cli.run worker: worker
-      end
-    end
-
-    describe '#env' do
-      it 'returns an env' do
-        expect(cli.env).to be_an Env
+        allow(cli).to receive(:worker) { worker }
+        expect(worker).to receive(:process)
+          .with([an_instance_of(Task), an_instance_of(Task)])
+        cli.run
       end
     end
 
@@ -141,19 +171,18 @@ module Producer::Core
         cli.load_recipe
       end
 
-      it 'assigns the evaluated recipe' do
-        cli.load_recipe
-        expect(cli.recipe.tasks.count).to be 2
+      it 'returns the recipe' do
+        expect(cli.load_recipe).to be_a Recipe
       end
     end
 
-    describe '#build_worker' do
+    describe '#worker' do
       it 'returns a worker' do
-        expect(cli.build_worker).to be_a Worker
+        expect(cli.worker).to be_a Worker
       end
 
       it 'assigns the CLI env' do
-        expect(cli.build_worker.env).to eq cli.env
+        expect(cli.worker.env).to eq cli.env
       end
     end
   end

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

@@ -22,9 +22,9 @@ module Producer::Core
       end
 
       describe '.define_test' do
-        let(:some_test_class) { Test }
+        let(:some_test) { Test }
 
-        before { described_class.define_test(:some_test, some_test_class) }
+        before { described_class.define_test(:some_test, some_test) }
 
         it 'defines a new test keyword' do
           expect(dsl).to respond_to :some_test
@@ -41,19 +41,38 @@ module Producer::Core
 
           it 'registers the test with current env' do
             dsl.some_test
-            expect(dsl.tests.first.env).to be env
+            expect(dsl.tests.last.env).to be env
           end
 
           it 'registers the test with given arguments' do
             dsl.some_test :some, :args
-            expect(dsl.tests.first.arguments).to eq [:some, :args]
+            expect(dsl.tests.last.arguments).to eq [:some, :args]
+          end
+
+          context 'when given test is callable' do
+            let(:some_test) { proc {} }
+
+            before { dsl.some_test }
+
+            it 'registers a condition test' do
+              expect(dsl.tests.last).to be_a Tests::ConditionTest
+            end
+
+            it 'registers the test with given block' do
+              expect(dsl.tests.last.condition_block).to be some_test
+            end
+
+            it 'registers the test with given arguments' do
+              dsl.some_test :some, :args
+              expect(dsl.tests.last.condition_args).to eq [:some, :args]
+            end
           end
         end
 
         context 'when a negated test keyword is called' do
           it 'registers a negated test' do
             dsl.no_some_test
-            expect(dsl.tests.first).to be_negated
+            expect(dsl.tests.last).to be_negated
           end
         end
       end
@@ -81,6 +100,15 @@ module Producer::Core
         it 'returns the value returned by the assigned block' do
           expect(dsl.evaluate).to eq block.call
         end
+
+        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
+          end
+        end
       end
     end
   end

data/spec/producer/core/env_spec.rb

@@ -3,10 +3,10 @@ require 'spec_helper'
 module Producer::Core
   describe Env do
     let(:output)  { StringIO.new }
-    subject(:env) { Env.new(output: output) }
+    subject(:env) { described_class.new(output: output) }
 
     describe '#initialize' do
-      it 'assigns $stdin as the default output' do
+      it 'assigns $stdin as the default input' do
         expect(env.input).to be $stdin
       end
 
@@ -18,12 +18,16 @@ module Producer::Core
         expect(env.registry).to be_empty
       end
 
+      it 'assigns verbose as false' do
+        expect(env.verbose).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) { Env.new }
+        subject(:env) { described_class.new }
 
         it 'assigns $stdout as the default output' do
           expect(env.output).to be $stdout
@@ -60,31 +64,12 @@ module Producer::Core
     describe '#target' do
       let(:target) { double 'target' }
 
-      it 'returns the defined target' do
+      it 'returns the assigned target' do
         env.target = target
         expect(env.target).to be target
       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 ERROR' do
-        expect(env.log_level).to eq Logger::ERROR
-      end
-
-      it 'uses our formatter' do
-        expect(env.logger.formatter).to be_a LoggerFormatter
-      end
-    end
-
     describe '#remote' do
       it 'builds a Remote with the current target' do
         env.target = 'some_hostname.example'
@@ -118,6 +103,33 @@ module Producer::Core
       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 ERROR' do
+        expect(env.logger.level).to eq Logger::ERROR
+      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'
@@ -125,24 +137,17 @@ module Producer::Core
       end
     end
 
-    describe '#log_level' do
-      it 'returns the logger level' do
-        expect(env.log_level).to eq env.logger.level
-      end
-    end
-
-    describe '#log_level=' do
-      it 'sets the logger level' do
-        env.log_level = Logger::DEBUG
-        expect(env.logger.level).to eq Logger::DEBUG
+    describe '#verbose?' do
+      it 'returns true when verbose is enabled' do
+        env.verbose = true
+        expect(env).to be_verbose
       end
     end
 
     describe '#dry_run?' do
-      before { env.dry_run = true }
-
       it 'returns true when dry run is enabled' do
-        expect(env.dry_run?).to be true
+        env.dry_run = true
+        expect(env).to be_dry_run
       end
     end
   end

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

@@ -102,6 +102,16 @@ module Producer::Core
         end
       end
 
+      describe '#test_macro' do
+        it 'defines the new test' do
+          condition_dsl = double 'condition dsl'
+          test_block = proc {}
+          expect(condition_dsl)
+            .to receive(:define_test).with(:some_test, test_block)
+          dsl.test_macro(:some_test, dsl: condition_dsl, &test_block)
+        end
+      end
+
       describe '#set' do
         it 'registers a key/value pair in env registry' do
           dsl.set :some_key, :some_value

data/spec/producer/core/remote_spec.rb

@@ -106,14 +106,23 @@ module Producer::Core
         expect(output.string).to eq arguments
       end
 
-      it 'raises an exception when the exit status code is not 0' do
-        story_with_new_channel do |ch|
-          ch.sends_exec command
-          ch.gets_data arguments
-          ch.gets_exit_status 1
+      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
-        expect { remote.execute command }
-          .to raise_error(RemoteCommandExecutionError)
       end
     end