producer-core 0.1.0

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

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+module Producer::Core
+  describe Recipe::DSL do
+    include FixturesHelpers
+
+    let(:code)    { proc { } }
+    let(:env)     { double('env').as_null_object }
+    subject(:dsl) { Recipe::DSL.new &code }
+
+    describe '.evaluate' do
+      let(:code) { 'nil' }
+
+      it 'builds a new DSL sandbox with given code' do
+        expect(Recipe::DSL).to receive(:new).once.with(code).and_call_original
+        Recipe::DSL.evaluate(code, env)
+      end
+
+      it 'evaluates the DSL sandbox code with given environment' do
+        dsl = double('dsl').as_null_object
+        allow(Recipe::DSL).to receive(:new) { dsl }
+        expect(dsl).to receive(:evaluate).with(env)
+        Recipe::DSL.evaluate(code, env)
+      end
+
+      it 'builds a recipe with evaluated tasks' do
+        dsl = Recipe::DSL.new('task(:some_task) { }')
+        allow(Recipe::DSL).to receive(:new) { dsl }
+        expect(Recipe).to receive(:new).with(dsl.tasks)
+        Recipe::DSL.evaluate(code, env)
+      end
+
+      it 'returns the recipe' do
+        recipe = double('recipe').as_null_object
+        allow(Recipe).to receive(:new) { recipe }
+        expect(Recipe::DSL.evaluate(code, env)).to be recipe
+      end
+    end
+
+    describe '#initialize' do
+      it 'assigns no task' do
+        expect(dsl.instance_eval { @tasks }).to be_empty
+      end
+
+      context 'when a string of code is given as argument' do
+        let(:code)    { 'some_code' }
+        subject(:dsl) { Recipe::DSL.new(code) }
+
+        it 'assigns the string of code' do
+          expect(dsl.instance_eval { @code }).to eq code
+        end
+      end
+
+      context 'when a code block is given as argument' do
+        it 'assigns the code block' do
+          expect(dsl.instance_eval { @block }).to be code
+        end
+      end
+    end
+
+    describe '#tasks' do
+      let(:code) { proc { task(:some_task) { } } }
+
+      it 'returns registered tasks' do
+        dsl.evaluate(env)
+        expect(dsl.tasks[0].name).to eq :some_task
+      end
+    end
+
+    describe '#evaluate' do
+      it 'evaluates its code' do
+        dsl = Recipe::DSL.new { throw :recipe_code }
+        expect { dsl.evaluate(env) }.to throw_symbol :recipe_code
+      end
+
+      it 'returns itself' do
+        expect(dsl.evaluate(env)).to eq dsl
+      end
+    end
+
+    context 'DSL specific methods' do
+      subject(:dsl) { Recipe::DSL.new(&code).evaluate(env) }
+
+      describe '#env' do
+        let(:code) { proc { env.some_message } }
+
+        it 'returns the current environment' do
+          expect(env).to receive(:some_message)
+          dsl.evaluate(env)
+        end
+      end
+
+      describe '#source' do
+        let(:filepath)  { fixture_path_for 'recipes/throw' }
+        let(:code)      { "source '#{filepath}'" }
+        subject(:dsl)   { Recipe::DSL.new code }
+
+        it 'sources the recipe given as argument' do
+          expect { dsl.evaluate(env) }.to throw_symbol :recipe_code
+        end
+      end
+
+      describe '#target' do
+        let(:code) { proc { target 'some_host.example' } }
+
+        it 'registers the target host in the env' do
+          expect(env).to receive(:target=).with('some_host.example')
+          dsl
+        end
+      end
+
+      describe '#task' do
+        let(:code) { proc { task(:some_task) { :some_value } } }
+
+        it 'builds a new evaluated task' do
+          expect(Task)
+            .to receive(:evaluate).with(:some_task, env) do |&block|
+              expect(block.call).to eq :some_value
+            end
+          dsl
+        end
+
+        it 'registers the new task' do
+          task = double('task').as_null_object
+          allow(Task).to receive(:new) { task }
+          expect(dsl.tasks).to include(task)
+        end
+      end
+    end
+  end
+end

data/spec/producer/core/recipe_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+module Producer::Core
+  describe Recipe do
+    include FixturesHelpers
+
+    subject(:recipe) { Recipe.new }
+
+    describe '.evaluate_from_file' do
+      let(:env)       { double('env') }
+      let(:filepath)  { fixture_path_for 'recipes/empty.rb' }
+
+      it 'delegates to DSL.evaluate with the recipe file content' do
+        expect(Recipe::DSL)
+          .to receive(:evaluate).with(File.read(filepath), env)
+        Recipe.evaluate_from_file(filepath, env)
+      end
+
+      it 'returns the evaluated recipe' do
+        recipe = double('recipe')
+        allow(Recipe::DSL).to receive(:evaluate) { recipe }
+        expect(Recipe.evaluate_from_file(filepath, env)).to be recipe
+      end
+    end
+
+    describe '#initialize' do
+      context 'without arguments' do
+        it 'assigns no task' do
+          expect(recipe.tasks).to be_empty
+        end
+      end
+
+      context 'when tasks are given as argument' do
+        let(:tasks)   { [Task.new(:some_task)] }
+        let(:recipe)  { Recipe.new(tasks) }
+
+        it 'assigns the tasks' do
+          expect(recipe.tasks).to eq tasks
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+module Producer::Core
+  describe Remote::Environment do
+    let(:variables)       { { 'FOO' => 'bar', 'BAZ' => 'qux' } }
+    subject(:environment) { Remote::Environment.new(variables) }
+
+    describe '#initialize' do
+      context 'when a hash is given' do
+        it 'assigns the key/value pairs' do
+          expect(environment.instance_eval { @variables }).to eq variables
+        end
+      end
+
+      context 'when a string is given' do
+        subject(:environment) { Remote::Environment.new("FOO=bar\nBAZ=qux") }
+
+        it 'assigns the key/value pairs' do
+          expect(environment.instance_eval { @variables }).to eq variables
+        end
+      end
+    end
+
+    describe '#has_key?' do
+      let(:key) { 'SOME_KEY' }
+
+      it 'forwards the message to @variables' do
+        expect(environment.instance_eval { @variables })
+          .to receive(:has_key?).with(key)
+        environment.has_key? key
+      end
+    end
+  end
+end

data/spec/producer/core/remote_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+module Producer::Core
+  describe Remote do
+    let(:hostname)    { 'some_host.example' }
+    subject(:remote)  { Remote.new(hostname) }
+
+    describe '#hostname' do
+      it 'returns the assignated hostname' do
+        expect(remote.hostname).to be hostname
+      end
+    end
+
+    describe '#session' do
+      it 'builds a new SSH session to the remote host' do
+        expect(Net::SSH).to receive(:start).with(hostname, Etc.getlogin)
+        remote.session
+      end
+
+      it 'returns the session' do
+        session = double('SSH session')
+        allow(Net::SSH).to receive(:start) { session }
+        expect(remote.session).to eq session
+      end
+
+      it 'memoizes the session' do
+        allow(Net::SSH).to receive(:start) { Object.new }
+        expect(remote.session).to be remote.session
+      end
+    end
+
+    describe '#execute', :ssh do
+      let(:arguments) { 'some remote command' }
+      let(:command)   { "echo #{arguments}" }
+
+      it 'executes the given command in a new channel' do
+        story_with_new_channel do |ch|
+          ch.sends_exec command
+          ch.gets_data arguments
+        end
+        remote.execute command
+        expect(story_completed?).to be
+      end
+
+      it 'returns the output' do
+        story_with_new_channel do |ch|
+          ch.sends_exec command
+          ch.gets_data arguments
+        end
+        expect(remote.execute(command)).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
+        end
+        expect { remote.execute(command) }
+          .to raise_error(RemoteCommandExecutionError)
+      end
+    end
+
+    describe '#environment', :ssh do
+      let(:command) { 'env' }
+      let(:output)  { "FOO=bar\nBAZ=qux" }
+
+      before do
+        story_with_new_channel do |ch|
+          ch.sends_exec command
+          ch.gets_data output
+        end
+      end
+
+      it 'builds a remote environment with the result of `env` command' do
+        expect(Remote::Environment).to receive(:new).with(output)
+        remote.environment
+      end
+
+      it 'returns the environment' do
+        environment = double('environment')
+        allow(Remote::Environment).to receive(:new) { environment }
+        expect(remote.environment).to be environment
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+module Producer::Core
+  describe Task::DSL do
+    let(:block)   { proc { } }
+    let(:env)     { double('env') }
+    subject(:dsl) { Task::DSL.new &block }
+
+    %w[echo sh].each do |action|
+      it "has `#{action}' action defined" do
+        expect(dsl).to respond_to action.to_sym
+      end
+    end
+
+    describe '.evaluate' do
+      let(:name) { :some_task }
+
+      it 'builds a new DSL sandbox with given code' do
+        expect(Task::DSL).to receive(:new).once.with(&block).and_call_original
+        Task::DSL.evaluate(name, env, &block)
+      end
+
+      it 'evaluates the DSL sandbox code with given environment' do
+        dsl = double('dsl').as_null_object
+        allow(Task::DSL).to receive(:new) { dsl }
+        expect(dsl).to receive(:evaluate).with(env)
+        Task::DSL.evaluate(name, env, &block)
+      end
+
+      it 'builds a task with its name, actions and condition' do
+        dsl = double('dsl').as_null_object
+        allow(Task::DSL).to receive(:new) { dsl }
+        allow(dsl).to receive(:actions) { [:some_action] }
+        allow(dsl).to receive(:condition) { :some_condition }
+        expect(Task)
+          .to receive(:new).with(:some_task, [:some_action], :some_condition)
+        Task::DSL.evaluate(name, env, &block)
+      end
+
+      it 'returns the task' do
+        task = double('task')
+        allow(Task).to receive(:new) { task }
+        expect(Task::DSL.evaluate(name, env, &block)).to be task
+      end
+    end
+
+    describe '.define_action' do
+      it 'defines a new action keyword' do
+        Task::DSL.define_action(:some_action, Object)
+        expect(dsl).to respond_to :some_action
+      end
+    end
+
+    describe '#initialize' do
+      it 'assigns no action' do
+        expect(dsl.actions).to be_empty
+      end
+
+      it 'assigns true as the condition' do
+        expect(dsl.instance_eval { @condition }).to be_true
+      end
+    end
+
+    describe '#actions' do
+      it 'returns the assigned actions' do
+        dsl.instance_eval { @actions = [:some_action] }
+        expect(dsl.actions).to eq [:some_action]
+      end
+    end
+
+    describe '#evaluate' do
+      let(:block) { proc { throw :task_code } }
+
+      it 'evaluates its code' do
+        expect { dsl.evaluate(env) }
+          .to throw_symbol :task_code
+      end
+
+      context 'when a defined keyword action is called' do
+        let(:some_action_class) { Class.new(Action) }
+        let(:block)             { proc { some_action } }
+
+        before do
+          Task::DSL.define_action(:some_action, some_action_class)
+          dsl.evaluate(env)
+        end
+
+        it 'registers the action' do
+          expect(dsl.actions.first).to be_an Action
+        end
+
+        it 'provides the env to the registered action' do
+          expect(dsl.actions.first.env).to eq env
+        end
+      end
+    end
+
+    context 'DSL specific methods' do
+      subject(:dsl) { Task::DSL.new(&block).evaluate(env) }
+
+      describe '#condition' do
+        context 'when a block is given' do
+          let(:block) { proc { condition { :some_value } } }
+
+          it 'builds a new evaluated condition' do
+            expect(Condition)
+              .to receive(:evaluate).with(env) do |&b|
+                expect(b.call).to eq :some_value
+              end
+            dsl
+          end
+
+          it 'assigns the new condition' do
+            condition = double('condition').as_null_object
+            allow(Condition).to receive(:evaluate) { condition }
+            expect(dsl.condition).to be condition
+          end
+        end
+      end
+    end
+
+    describe '#condition' do
+      context 'without block' do
+        it 'returns the assigned condition' do
+          dsl.instance_eval { @condition = :some_condition }
+          expect(dsl.condition).to be :some_condition
+        end
+      end
+    end
+  end
+end

data/spec/producer/core/task_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+module Producer::Core
+  describe Task do
+    let(:name)      { :some_task }
+    let(:action)    { double('action') }
+    let(:condition) { double('condition') }
+    subject(:task)  { Task.new(name, [action], condition) }
+
+    describe '.evaluate' do
+      let(:env)   { double('env') }
+      let(:block) { proc { :some_value } }
+
+      it 'delegates to DSL.evaluate' do
+        expect(Task::DSL)
+          .to receive(:evaluate).with(name, env) do |&b|
+            expect(b.call).to eq :some_value
+          end
+        Task.evaluate(name, env, &block)
+      end
+
+      it 'returns the evaluated task' do
+        task = double('task')
+        allow(Task::DSL).to receive(:evaluate) { task }
+        expect(Task.evaluate(name, env, &block)).to be task
+      end
+    end
+
+    describe '#initialize' do
+      it 'assigns the name' do
+        expect(task.instance_eval { @name }).to eq name
+      end
+
+      it 'assigns the actions' do
+        expect(task.instance_eval { @actions }).to eq [action]
+      end
+
+      it 'assigns the condition' do
+        expect(task.instance_eval { @condition }).to eq condition
+      end
+
+      context 'when only the name is given as argument' do
+        subject(:task)  { Task.new(name) }
+
+        it 'assigns no action' do
+          expect(task.actions).to be_empty
+        end
+
+        it 'assigns a truthy condition' do
+          expect(task.condition).to be_true
+        end
+      end
+    end
+
+    describe '#name' do
+      it 'returns its name' do
+        expect(task.name).to eq name
+      end
+    end
+
+    describe '#actions' do
+      it 'returns the assigned actions' do
+        expect(task.actions).to eq [action]
+      end
+    end
+
+    describe '#condition' do
+      it 'returns the assigned condition' do
+        expect(task.condition).to be condition
+      end
+    end
+
+    describe '#condition_met?' do
+      context 'when condition is truthy' do
+        let(:condition) { Condition.new([], true) }
+
+        it 'returns true' do
+          expect(task.condition_met?).to be true
+        end
+      end
+
+      context 'when condition is falsy' do
+        let(:condition) { Condition.new([], false) }
+
+        it 'returns false' do
+          expect(task.condition_met?).to be false
+        end
+      end
+    end
+  end
+end

data/spec/producer/core/test_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+module Producer::Core
+  describe Test do
+    let(:env)         { double 'env' }
+    let(:arguments)   { [:some, :arguments] }
+    subject(:action)  { Test.new(env, *arguments) }
+
+    describe '#initialize' do
+      it 'assigns the env' do
+        expect(action.instance_eval { @env }).to be env
+      end
+      it 'assigns the arguments' do
+        expect(action.instance_eval { @arguments }).to eq arguments
+      end
+    end
+
+    describe '#env' do
+      it 'returns the assigned env' do
+        expect(action.env).to be env
+      end
+    end
+
+    describe '#arguments' do
+      it 'returns the assigned arguments' do
+        expect(action.arguments).to eq arguments
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+module Producer::Core
+  describe Tests::HasEnv do
+    let(:env)           { Env.new }
+    let(:variable_name) { :some_variable_name }
+    subject(:has_env)   { Tests::HasEnv.new(env, variable_name) }
+
+    it 'is a kind of test' do
+      expect(has_env).to be_a Test
+    end
+
+    describe '#success?' do
+      let(:environment) { double('environment') }
+
+      before do
+        allow(env.remote).to receive(:environment) { environment }
+      end
+
+      it 'stringifies the queried variable name' do
+        expect(environment).to receive(:has_key?).with(kind_of(String))
+        has_env.success?
+      end
+
+      it 'upcases the queried variable name' do
+        expect(environment).to receive(:has_key?).with('SOME_VARIABLE_NAME')
+        has_env.success?
+      end
+
+      it 'returns true when remote environment var is defined' do
+        allow(environment).to receive(:has_key?) { true }
+        expect(has_env.success?).to be true
+      end
+
+      it 'returns false when remote environment var is not defined' do
+        allow(environment).to receive(:has_key?) { false }
+        expect(has_env.success?).to be false
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'producer/core'
+
+require 'support/exit_helpers'
+require 'support/fixtures_helpers'
+require 'support/net_ssh_story_helpers'
+require 'support/tests_helpers'
+
+
+RSpec.configure do |c|
+  c.treat_symbols_as_metadata_keys_with_true_values = true
+
+  c.include NetSSHStoryHelpers, :ssh
+  c.before(:each, :ssh) do
+    allow(remote).to receive(:session) { connection }
+  end
+end

data/spec/support/exit_helpers.rb

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

data/spec/support/fixtures_helpers.rb

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,17 @@
+module NetSSHStoryHelpers
+  require 'net/ssh/test'
+  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 story_completed?
+    socket.script.events.empty?
+  end
+end

data/spec/support/tests_helpers.rb

@@ -0,0 +1,9 @@
+module TestsHelpers
+  def test_ok
+    double('test', success?: true)
+  end
+
+  def test_ko
+    double('test', success?: false)
+  end
+end