producer-core 0.1.12 → 0.1.13

data/spec/producer/core/actions/shell_command_spec.rb

@@ -1,22 +1,24 @@
 require 'spec_helper'
 
 module Producer::Core
-  describe Actions::ShellCommand do
-    let(:env)           { Env.new(output: StringIO.new) }
-    let(:command_args)  { 'hello from remote host' }
-    let(:command)       { "echo #{command_args}" }
-    subject(:sh)        { Actions::ShellCommand.new(env, command) }
+  module Actions
+    describe ShellCommand, :env do
+      let(:command_args)  { 'hello from remote host' }
+      let(:command)       { "echo #{command_args}" }
+      subject(:sh)        { ShellCommand.new(env, command) }
 
-    describe '#apply' do
-      it 'executes the remote command' do
-        expect(sh.remote).to receive(:execute).with(command)
-        sh.apply
-      end
+      it_behaves_like 'action'
+
+      describe '#apply' do
+        it 'executes the remote command' do
+          expect_execution(command)
+          sh.apply
+        end
 
-      it 'writes the returned output with a record separator' do
-        allow(sh.remote).to receive(:execute) { command_args }
-        sh.apply
-        expect(sh.output.string).to eq "#{command_args}\n"
+        it 'writes the returned output with a record separator' do
+          sh.apply
+          expect(output).to eq "#{command_args}\n"
+        end
       end
     end
   end

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

@@ -1,76 +1,78 @@
 require 'spec_helper'
 
 module Producer::Core
-  describe Condition::DSL do
-    let(:block)   { proc { :some_condition_code } }
-    let(:env)     { double 'env' }
-    subject(:dsl) { Condition::DSL.new(env, &block) }
+  class Condition
+    describe DSL do
+      let(:block)   { proc { :some_condition_code } }
+      let(:env)     { double 'env' }
+      subject(:dsl) { DSL.new(env, &block) }
 
-    %w[has_dir has_env has_file].each do |test|
-      it "has `#{test}' test defined" do
-        expect(dsl).to respond_to test.to_sym
+      %w[file_contains has_dir has_env has_file].each do |test|
+        it "has `#{test}' test defined" do
+          expect(dsl).to respond_to test.to_sym
+        end
       end
-    end
-
-    describe '.define_test' do
-      let(:some_test_class) { Test }
 
-      before { Condition::DSL.define_test(:some_test, some_test_class) }
-
-      it 'defines a new test keyword' do
-        expect(dsl).to respond_to :some_test
-      end
+      describe '.define_test' do
+        let(:some_test_class) { Test }
 
-      it 'defines the negated test' do
-        expect(dsl).to respond_to :no_some_test
-      end
+        before { described_class.define_test(:some_test, some_test_class) }
 
-      context 'when a test keyword is called' do
-        it 'registers the test' do
-          expect { dsl.some_test }.to change { dsl.tests.count }.by 1
+        it 'defines a new test keyword' do
+          expect(dsl).to respond_to :some_test
         end
 
-        it 'registers the test with current env' do
-          dsl.some_test
-          expect(dsl.tests.first.env).to be env
+        it 'defines the negated test' do
+          expect(dsl).to respond_to :no_some_test
         end
 
-        it 'registers the test with given arguments' do
-          dsl.some_test :some, :args
-          expect(dsl.tests.first.arguments).to eq [:some, :args]
+        context 'when a test keyword is called' do
+          it 'registers the test' do
+            expect { dsl.some_test }.to change { dsl.tests.count }.by 1
+          end
+
+          it 'registers the test with current env' do
+            dsl.some_test
+            expect(dsl.tests.first.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]
+          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
+        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
+          end
         end
       end
-    end
 
-    describe '#initialize' do
-      it 'assigns the env' do
-        expect(dsl.env).to be env
-      end
+      describe '#initialize' do
+        it 'assigns the env' do
+          expect(dsl.env).to be env
+        end
 
-      it 'assigns the code' do
-        expect(dsl.block).to be block
-      end
+        it 'assigns the code' do
+          expect(dsl.block).to be block
+        end
 
-      it 'assigns no test' do
-        expect(dsl.tests).to be_empty
+        it 'assigns no test' do
+          expect(dsl.tests).to be_empty
+        end
       end
-    end
 
-    describe '#evaluate' do
-      it 'evaluates its code' do
-        dsl = described_class.new(env) { throw :condition_code }
-        expect { dsl.evaluate }.to throw_symbol :condition_code
-      end
+      describe '#evaluate' do
+        it 'evaluates its code' do
+          dsl = described_class.new(env) { throw :condition_code }
+          expect { dsl.evaluate }.to throw_symbol :condition_code
+        end
 
-      it 'returns the value returned by the assigned block' do
-        expect(dsl.evaluate).to eq block.call
+        it 'returns the value returned by the assigned block' do
+          expect(dsl.evaluate).to eq block.call
+        end
       end
     end
   end

data/spec/producer/core/env_spec.rb

@@ -17,12 +17,16 @@ module Producer::Core
         expect(env.target).not_to be
       end
 
+      it 'assigns an empty registry' do
+        expect(env.registry).to be_empty
+      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 eq input
+          expect(env.input).to be input
         end
       end
 
@@ -31,7 +35,16 @@ module Producer::Core
         subject(:env) { described_class.new(output: output) }
 
         it 'assigns the given output' do
-          expect(env.output).to eq output
+          expect(env.output).to be 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
@@ -62,5 +75,20 @@ module Producer::Core
         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
+    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
   end
 end

data/spec/producer/core/prompter_spec.rb

@@ -4,7 +4,6 @@ module Producer::Core
   describe Prompter do
     let(:input)         { StringIO.new }
     let(:output)        { StringIO.new }
-    let(:env)           { Env.new(input: input, output: output) }
     subject(:prompter)  { Prompter.new(input, output) }
 
     describe '#initialize' do

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

@@ -1,102 +1,118 @@
 require 'spec_helper'
 
 module Producer::Core
-  describe Recipe::DSL do
-    include FixturesHelpers
+  class Recipe
+    describe DSL do
+      include FixturesHelpers
 
-    let(:code)    { proc { :some_recipe_code } }
-    let(:env)     { Env.new }
-    subject(:dsl) { Recipe::DSL.new(env, &code) }
+      let(:code)    { proc { :some_recipe_code } }
+      let(:env)     { Env.new }
+      subject(:dsl) { DSL.new(env, &code) }
 
-    describe '#initialize' do
-      it 'assigns the given env' do
-        expect(dsl.env).to be env
-      end
+      describe '#initialize' do
+        it 'assigns the given env' do
+          expect(dsl.env).to be env
+        end
 
-      it 'assigns no task' do
-        expect(dsl.tasks).to be_empty
-      end
+        it 'assigns no task' do
+          expect(dsl.tasks).to be_empty
+        end
 
-      context 'when a string of code is given as argument' do
-        let(:code)    { 'some_code' }
-        subject(:dsl) { described_class.new(env, code) }
+        context 'when a string of code is given as argument' do
+          let(:code)    { 'some_code' }
+          subject(:dsl) { described_class.new(env, code) }
 
-        it 'assigns the string of code' do
-          expect(dsl.code).to eq code
+          it 'assigns the string of code' do
+            expect(dsl.code).to eq code
+          end
         end
-      end
 
-      context 'when a code block is given as argument' do
-        it 'assigns the code block' do
-          expect(dsl.block).to be code
+        context 'when a code block is given as argument' do
+          it 'assigns the code block' do
+            expect(dsl.block).to be code
+          end
         end
       end
-    end
 
-    describe '#tasks' do
-      let(:code) { proc { task(:some_task) {} } }
+      describe '#tasks' do
+        let(:code) { proc { task(:some_task) {} } }
 
-      it 'returns registered tasks' do
-        dsl.evaluate
-        expect(dsl.tasks[0].name).to eq :some_task
+        it 'returns registered tasks' do
+          dsl.evaluate
+          expect(dsl.tasks[0].name).to eq :some_task
+        end
       end
-    end
 
-    describe '#evaluate' do
-      it 'evaluates its code' do
-        dsl = described_class.new(env) { throw :recipe_code }
-        expect { dsl.evaluate }.to throw_symbol :recipe_code
-      end
+      describe '#evaluate' do
+        it 'evaluates its code' do
+          dsl = described_class.new(env) { throw :recipe_code }
+          expect { dsl.evaluate }.to throw_symbol :recipe_code
+        end
 
-      it 'returns itself' do
-        expect(dsl.evaluate).to eq dsl
+        it 'returns itself' do
+          expect(dsl.evaluate).to eq dsl
+        end
       end
-    end
 
-    describe '#source' do
-      let(:filepath)  { fixture_path_for 'recipes/throw' }
+      describe '#source' do
+        let(:filepath)  { fixture_path_for 'recipes/throw' }
 
-      it 'sources the recipe given as argument' do
-        expect { dsl.source filepath }.to throw_symbol :recipe_code
+        it 'sources the recipe given as argument' do
+          expect { dsl.source filepath }.to throw_symbol :recipe_code
+        end
       end
-    end
 
-    describe '#target' do
-      let(:host) { 'some_host.example' }
+      describe '#target' do
+        let(:host) { 'some_host.example' }
 
-      it 'registers the target host in the env' do
-        dsl.target host
-        expect(env.target).to eq host
+        it 'registers the target host in the env' do
+          dsl.target host
+          expect(env.target).to eq host
+        end
       end
-    end
 
-    describe '#task' do
-      it 'registers a new evaluated task' do
-        expect { dsl.task(:some_task) { :some_task_code } }
-          .to change { dsl.tasks.count }.by 1
+      describe '#task' do
+        it 'registers a new evaluated task' do
+          expect { dsl.task(:some_task) { :some_task_code } }
+            .to change { dsl.tasks.count }.by 1
+        end
       end
-    end
 
-    describe '#macro' do
-      it 'defines the new recipe keyword' do
-        dsl.macro :hello
-        expect(dsl).to respond_to(:hello)
-      end
+      describe '#macro' do
+        it 'defines the new recipe keyword' do
+          dsl.macro :hello
+          expect(dsl).to respond_to(:hello)
+        end
+
+        context 'when a defined macro is called' do
+          before { dsl.macro(:hello) { :some_macro_code } }
+
+          it 'registers the new task' do
+            expect { dsl.hello }.to change { dsl.tasks.count }.by 1
+          end
+        end
 
-      context 'when a defined macro is called' do
-        before { dsl.macro(:hello) { :some_macro_code } }
+        context 'when a defined macro is called with arguments' do
+          before { dsl.macro(:hello) { |a, b| echo a, b } }
 
-        it 'registers the new task' do
-          expect { dsl.hello }.to change { dsl.tasks.count }.by 1
+          it 'evaluates task code with arguments' do
+            dsl.hello :some, :args
+            expect(dsl.tasks.first.actions.first.arguments).to eq [:some, :args]
+          end
         end
       end
 
-      context 'when a defined macro is called with arguments' do
-        before { dsl.macro(:hello) { |a, b| echo a, b } }
+      describe '#set' do
+        it 'registers a key/value pair in env registry' do
+          dsl.set :some_key, :some_value
+          expect(env[:some_key]).to eq :some_value
+        end
+      end
 
-        it 'evaluates task code with arguments' do
-          dsl.hello :some, :args
-          expect(dsl.tasks.first.actions.first.arguments).to eq [:some, :args]
+      describe '#get' do
+        it 'fetches a value from the registry at given index' do
+          dsl.set :some_key, :some_value
+          expect(dsl.get :some_key).to eq :some_value
         end
       end
     end

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

@@ -1,48 +1,50 @@
 require 'spec_helper'
 
 module Producer::Core
-  describe Remote::Environment do
-    let(:variables)       { { 'FOO' => 'bar', 'BAZ' => 'qux' } }
-    let(:string)          { "FOO=bar\nBAZ=qux" }
-    let(:argument)        { variables }
-    subject(:environment) { Remote::Environment.new(argument) }
+  class Remote
+    describe Environment do
+      let(:variables)       { { 'FOO' => 'bar', 'BAZ' => 'qux' } }
+      let(:string)          { "FOO=bar\nBAZ=qux" }
+      let(:argument)        { variables }
+      subject(:environment) { Environment.new(argument) }
 
-    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 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 variables
+        end
       end
-    end
 
-    describe '.new_from_string' do
-      it 'returns a new instance with converted keys and values' do
-        environment = described_class.new_from_string string
-        expect(environment.variables).to eq variables
+      describe '.new_from_string' do
+        it 'returns a new instance with converted keys and values' do
+          environment = described_class.new_from_string string
+          expect(environment.variables).to eq variables
+        end
       end
-    end
 
-    describe '#initialize' do
-      it 'assigns the key/value pairs' do
-        expect(environment.variables).to eq variables
+      describe '#initialize' do
+        it 'assigns the key/value pairs' do
+          expect(environment.variables).to eq variables
+        end
       end
-    end
 
-    describe '#key?' do
-      context 'when key is defined' do
-        it 'returns true' do
-          expect(environment.key? 'FOO').to be true
+      describe '#key?' do
+        context 'when key is defined' do
+          it 'returns true' do
+            expect(environment.key? 'FOO').to be true
+          end
         end
-      end
 
-      context 'when key is not defined' do
-        it 'returns false' do
-          expect(environment.key? 'INEXISTENT_KEY').to be false
+        context 'when key is not defined' do
+          it 'returns false' do
+            expect(environment.key? 'INEXISTENT_KEY').to be false
+          end
         end
       end
-    end
 
-    describe '#[]' do
-      it 'returns the value indexed by given key' do
-        expect(environment['FOO']).to eq 'bar'
+      describe '#[]' do
+        it 'returns the value indexed by given key' do
+          expect(environment['FOO']).to eq 'bar'
+        end
       end
     end
   end