producer-core 0.3.0 → 0.3.1

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

@@ -1,140 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  class Recipe
-    describe DSL do
-      include FixturesHelpers
-
-      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
-
-        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) }
-
-          it 'assigns the string of code' do
-            expect(dsl.code).to eq code
-          end
-        end
-
-        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
-
-      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
-        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
-
-        it 'returns itself' do
-          expect(dsl.evaluate).to eq dsl
-        end
-      end
-
-      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
-        end
-      end
-
-      describe '#target' do
-        let(:host) { 'some_host.example' }
-
-        context 'when env has no assigned target' do
-          it 'registers the target host in the env' do
-            dsl.target host
-            expect(env.target).to eq host
-          end
-        end
-
-        context 'when env has an assigned target' do
-          before { env.target = 'already_assigned_host.example' }
-
-          it 'does not change env target' do
-            expect { dsl.target host }.not_to change { env.target }
-          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
-        end
-      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 with arguments' do
-          before { dsl.macro(:hello) { |a, b| echo a, b } }
-
-          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
-
-      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
-          expect(env[:some_key]).to eq :some_value
-        end
-      end
-
-      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
-  end
-end

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

@@ -1,123 +0,0 @@
-require 'spec_helper'
-
-module Producer::Core
-  class Task
-    describe DSL do
-      let(:block)   { proc {} }
-      let(:env)     { Env.new }
-      subject(:dsl) { DSL.new(env, &block) }
-
-      %w[
-        echo
-        sh
-        mkdir
-        file_append
-        file_replace_content
-        file_write
-      ].each do |action|
-        it "has `#{action}' action defined" do
-          expect(dsl).to respond_to action.to_sym
-        end
-      end
-
-      describe '.define_action' do
-        let(:some_action_class) { Class.new(Action) }
-
-        before { described_class.define_action(:some_action, some_action_class) }
-
-        it 'defines a new action keyword' do
-          expect(dsl).to respond_to :some_action
-        end
-
-        context 'when an action keyword is called' do
-          it 'registers the action' do
-            expect { dsl.some_action }.to change { dsl.actions.count }.by 1
-          end
-
-          it 'registers the action with current env' do
-            dsl.some_action
-            expect(dsl.actions.first.env).to be env
-          end
-
-          it 'registers the action with given arguments' do
-            dsl.some_action :some, :args
-            expect(dsl.actions.first.arguments).to eq [:some, :args]
-          end
-        end
-      end
-
-      describe '#initialize' do
-        it 'assigns the given env' do
-          expect(dsl.env).to be env
-        end
-
-        it 'assigns the given block' do
-          expect(dsl.block).to be block
-        end
-
-        it 'assigns no action' do
-          expect(dsl.actions).to be_empty
-        end
-
-        it 'assigns true as the condition' do
-          expect(dsl.condition).to be true
-        end
-      end
-
-      describe '#evaluate' do
-        let(:block) { proc { throw :task_code } }
-
-        it 'evaluates its code' do
-          expect { dsl.evaluate }
-            .to throw_symbol :task_code
-        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
-
-      describe '#condition' do
-        context 'when a block is given' do
-          it 'assigns a new evaluated condition' do
-            dsl.condition { :some_return_value }
-            expect(dsl.condition.return_value).to eq :some_return_value
-          end
-        end
-      end
-
-      describe '#ask' do
-        let(:question)        { 'Which letter?' }
-        let(:choices)         { [[:a, ?A], [:b, ?B]] }
-        let(:prompter_class)  { double('prompter class').as_null_object }
-        subject(:ask)         { dsl.ask question, choices,
-                                prompter: prompter_class }
-
-        it 'builds a prompter' do
-          expect(prompter_class).to receive(:new).with(env.input, env.output)
-          ask
-        end
-
-        it 'prompts and returns the choice' do
-          prompter = double 'prompter'
-          allow(prompter_class).to receive(:new) { prompter }
-          allow(prompter).to receive(:prompt) { :choice }
-          expect(ask).to eq :choice
-        end
-      end
-
-      describe '#get' do
-        let(:env) { Env.new(registry: { some_key: :some_value }) }
-
-        it 'fetches a value from the registry at given index' do
-          expect(dsl.get :some_key).to eq :some_value
-        end
-      end
-    end
-  end
-end