foreman_deployments 0.0.1

data/test/unit/lib/tasks/creation_task_definition_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+class CreationTaskDefinitionTest < ActiveSupport::TestCase
+  let(:definition_class) { ForemanDeployments::Tasks::CreationTaskDefinition }
+
+  describe 'build' do
+    test 'it returns instance of HostCreationTaskDefinition for Host' do
+      definition = definition_class.build('class' => 'Host')
+      assert_equal(ForemanDeployments::Tasks::HostCreationTaskDefinition, definition.class)
+    end
+
+    test 'it returns instance of HostCreationTaskDefinition for Host::Managed' do
+      definition = definition_class.build('class' => 'Host::Managed')
+      assert_equal(ForemanDeployments::Tasks::HostCreationTaskDefinition, definition.class)
+    end
+
+    test 'it returns instance of CreationTaskDefinition for other classes' do
+      definition = definition_class.build('class' => 'Architecture')
+      assert_equal(ForemanDeployments::Tasks::CreationTaskDefinition, definition.class)
+    end
+  end
+
+  describe 'object creation' do
+    test 'it returns instance of the class' do
+      object = definition_class.create_object(
+        'class' => 'Architecture'
+      )
+      assert_equal(Architecture, object.class)
+    end
+
+    test 'it sets the parameters' do
+      object = definition_class.create_object(
+        'class' => 'Architecture',
+        'params' => {
+          'name' => 'test'
+        }
+      )
+      assert_equal('test', object.name)
+    end
+
+    test "it ignores parameters that don't exist" do
+      object = definition_class.create_object(
+        'class' => 'Architecture',
+        'params' => {
+          'name' => 'test',
+          'unknown' => 123
+        }
+      )
+      assert_equal('test', object.name)
+    end
+  end
+
+  test 'it returns correct dynflow action' do
+    action = definition_class.build('class' => 'Architecture').dynflow_action
+    assert_equal(ForemanDeployments::Tasks::CreationTaskDefinition::Action, action)
+  end
+end

data/test/unit/lib/tasks/host_creation_task_definition_test.rb

@@ -0,0 +1,10 @@
+require 'test_helper'
+
+class HostCreationTaskDefinitionTest < ActiveSupport::TestCase
+  let(:definition_class) { ForemanDeployments::Tasks::HostCreationTaskDefinition }
+
+  test 'it returns correct dynflow action' do
+    action = definition_class.build('class' => 'Host').dynflow_action
+    assert_equal(ForemanDeployments::Tasks::HostCreationTaskDefinition::Action, action)
+  end
+end

data/test/unit/lib/tasks/search_task_definition_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+class SearchTaskDefinitionTest < ActiveSupport::TestCase
+  class DummyModel < ActiveRecord::Base
+  end
+
+  setup do
+    @params = {
+      'class' => 'SearchTaskDefinitionTest::DummyModel',
+      'search_term' => 'a = b'
+    }
+    @params = HashWithIndifferentAccess[@params]
+  end
+
+  describe 'validate' do
+    test 'fails, if could not find a matching object' do
+      task = ForemanDeployments::Tasks::SearchTaskDefinition.new(@params)
+      DummyModel.expects(:search_for).returns([])
+
+      result = task.validate
+
+      assert_equal(1, result.messages.count)
+      assert_match(
+        "SearchTaskDefinitionTest::DummyModel.search_for('a = b') didn't return valid objects",
+        result.messages.first
+      )
+    end
+
+    test 'succeeds, if there is at least one matching object' do
+      task = ForemanDeployments::Tasks::SearchTaskDefinition.new(@params)
+      DummyModel.expects(:search_for).returns([mock('DummyModel1')])
+
+      result = task.validate
+
+      assert result.valid?
+    end
+  end
+
+  test 'should return valid search results for validation process' do
+    task = ForemanDeployments::Tasks::SearchTaskDefinition.new(@params)
+    search_result1 = mock('DummyModel1')
+    search_result1.expects(:id).returns(1)
+    DummyModel.expects(:search_for).returns([search_result1])
+
+    result = task.preliminary_output
+
+    assert_equal [search_result1], result['results']
+  end
+end

data/test/unit/lib/tasks/stack_deploy_action_test.rb

@@ -0,0 +1,83 @@
+require 'test_helper'
+require 'dynflow/testing'
+
+class StackDeployActionTest < ActiveSupport::TestCase
+  include ::Dynflow::Testing
+
+  class TestTaskDefinition < ForemanDeployments::Tasks::BaseDefinition
+    class Action < ForemanDeployments::Tasks::BaseAction; end
+
+    def dynflow_action
+      Action
+    end
+  end
+
+  def get_planned_params(task)
+    task.planned.plan_input[0]
+  end
+
+  describe 'plan' do
+    test 'plans actions in deployment' do
+      stack = ForemanDeployments::StackDefinition.new(
+        :task1 => TestTaskDefinition.new,
+        :task2 => TestTaskDefinition.new,
+        :task3 => TestTaskDefinition.new
+      )
+
+      stack.tasks.each do |_task_id, task|
+        task.expects(:plan).once
+      end
+
+      create_and_plan_action(ForemanDeployments::Tasks::StackDeployAction, stack)
+    end
+
+    test 'planned actions recieve dereferenced input' do
+      task3 = TestTaskDefinition.new({})
+      task2 = TestTaskDefinition.new(
+        :param => ForemanDeployments::TaskReference.new(:task3, :id, task3)
+      )
+      task1 = TestTaskDefinition.new(
+        :param => ForemanDeployments::TaskReference.new(:task2, :some_value, task2)
+      )
+
+      stack = ForemanDeployments::StackDefinition.new(
+        :task1 => task1,
+        :task2 => task2,
+        :task3 => task3
+      )
+
+      create_and_plan_action(ForemanDeployments::Tasks::StackDeployAction, stack)
+
+      task_params = get_planned_params(task1)
+      assert_equal(Dynflow::ExecutionPlan::OutputReference, task_params['param'].class)
+      assert_equal(['some_value'], task_params['param'].subkeys)
+
+      task_params = get_planned_params(task2)
+      assert_equal(Dynflow::ExecutionPlan::OutputReference, task_params['param'].class)
+      assert_equal(['id'], task_params['param'].subkeys)
+
+      assert_equal({}, get_planned_params(task3))
+    end
+
+    test 'plans referenced tasks only once' do
+      task2 = TestTaskDefinition.new({})
+      task1 = TestTaskDefinition.new(
+        :param => ForemanDeployments::TaskReference.new(:task2, :some_value, task2)
+      )
+
+      stack = ForemanDeployments::StackDefinition.new(
+        :task1 => task1,
+        :task2 => task2
+      )
+
+      planned = mock
+      planned.stubs(:output)
+
+      stack.tasks.each do |_task_id, task|
+        task.expects(:plan).once.returns(planned)
+      end
+
+      create_and_plan_action(ForemanDeployments::Tasks::StackDeployAction, stack)
+    end
+  end
+end

data/test/unit/lib/tasks/wait_until_built_task_definition_test.rb

@@ -0,0 +1,71 @@
+require 'test_helper'
+
+class WaitUntilBuiltTaskDefinitionTest < ActiveSupport::TestCase
+  let(:definition_class) { ForemanDeployments::Tasks::WaitUntilBuiltTaskDefinition }
+
+  describe 'build' do
+    test 'it returns instance of WaitUntilBuiltTaskDefinition' do
+      definition = definition_class.build
+      assert_equal(ForemanDeployments::Tasks::WaitUntilBuiltTaskDefinition, definition.class)
+    end
+  end
+
+  describe 'build status' do
+    setup do
+      @reports = []
+      @host = stub(
+        :reports => @reports
+      )
+    end
+
+    test 'is negative for nil' do
+      status = definition_class.build_status(nil)
+      assert_equal(false, status['build'])
+    end
+
+    test 'is negative for host with only one report' do
+      @reports << stub(:error? => false)
+      status = definition_class.build_status(@host)
+      assert_equal(false, status['build'])
+    end
+
+    test 'is negative for host with two reports, where the last failed' do
+      @reports << stub(:error? => false)
+      @reports << stub(:error? => true)
+      status = definition_class.build_status(@host)
+      assert_equal(false, status['build'])
+    end
+
+    test 'is positive for host with two reports, where the last succeeded' do
+      @reports << stub(:error? => false)
+      @reports << stub(:error? => true)
+      @reports << stub(:error? => false)
+      status = definition_class.build_status(@host)
+      assert_equal(true, status['build'])
+    end
+  end
+
+  describe 'validation' do
+    setup do
+      @definition = definition_class.build
+    end
+
+    test 'it is valid when a host_id is passed' do
+      @definition.configure('host_id' => 1)
+      result = @definition.validate
+
+      assert result.valid?
+    end
+
+    test 'it is invalid when a host_id is missing' do
+      result = @definition.validate
+      refute result.valid?
+      assert result.messages.include?("'host_id' is a required parameter")
+    end
+  end
+
+  test 'it returns correct dynflow action' do
+    action = definition_class.build.dynflow_action
+    assert_equal(ForemanDeployments::Tasks::WaitUntilBuiltTaskDefinition::Action, action)
+  end
+end

data/test/unit/lib/validation/dereference_visitor_test.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+class DereferenceVisitorTest < ActiveSupport::TestCase
+  class TestTask < ForemanDeployments::Tasks::BaseDefinition
+    def validate
+      ForemanDeployments::Validation::ValidationResult.new
+    end
+
+    def preliminary_output
+      {}
+    end
+  end
+
+  setup do
+    @visitor = ForemanDeployments::Validation::DereferenceVisitor.new
+  end
+
+  test 'it resolves dependencies' do
+    # We're also testing presence of the cache by setting .expects(:preliminary_output).once
+    # and having multiple references to a single task
+
+    task3 = TestTask.new
+    task3.expects(:preliminary_output).once.returns('result' => 789)
+
+    task2 = TestTask.new(
+      'param1' => 2,
+      'param2' => ForemanDeployments::TaskReference.new('task3', 'result', task3)
+    )
+    task2.expects(:preliminary_output).once.returns('result1' => 123, 'result2' => 456)
+
+    task1 = TestTask.new(
+      'param1' => 1,
+      'param2' => ForemanDeployments::TaskReference.new('task2', 'result1', task2),
+      'param3' => ForemanDeployments::TaskReference.new('task2', 'result2', task2)
+    )
+
+    definition = ForemanDeployments::StackDefinition.new(
+      'task1' => task1,
+      'task2' => task2,
+      'task3' => task3
+    )
+    definition.accept(@visitor)
+
+    assert_equal({}, task3.parameters)
+    assert_equal({ 'param1' => 2, 'param2' => 789 }, task2.parameters)
+    assert_equal({ 'param1' => 1, 'param2' => 123, 'param3' => 456 }, task1.parameters)
+  end
+end

data/test/unit/lib/validation/remove_ids_visitor_test.rb

@@ -0,0 +1,90 @@
+require 'test_helper'
+
+class RemoveIdsVisitorTest < ActiveSupport::TestCase
+  class TestTask < ForemanDeployments::Tasks::CreationTaskDefinition
+    def validate
+      ForemanDeployments::Validation::ValidationResult.new
+    end
+
+    def preliminary_output
+      {}
+    end
+  end
+
+  setup do
+    @visitor = ForemanDeployments::Validation::RemoveIdsVisitor.new
+  end
+
+  test 'it turns id reference into object reference in parameters' do
+    task2 = TestTask.new
+
+    task2_ref = ForemanDeployments::TaskReference.new('task2', 'resource.id')
+    task2_ref.task = task2
+
+    task1 = TestTask.new(
+      :test_resource_id => task2_ref
+    )
+
+    definition = ForemanDeployments::StackDefinition.new(
+      'task1' => task1,
+      'task2' => task2
+    )
+    definition.accept(@visitor)
+
+    assert_equal('resource', task1.parameters['test_resource'].output_key)
+  end
+
+  test 'it turns single reference to multiple ids into an object reference' do
+    task2 = TestTask.new
+
+    task2_ref = ForemanDeployments::TaskReference.new('task2', 'resource.ids')
+    task2_ref.task = task2
+
+    task1 = TestTask.new(
+      :test_resource_ids => task2_ref
+    )
+
+    definition = ForemanDeployments::StackDefinition.new(
+      'task1' => task1,
+      'task2' => task2
+    )
+    definition.accept(@visitor)
+
+    assert_equal('resources', task1.parameters['test_resources'].output_key)
+  end
+
+  test 'it turns array of id references into array of object references in parameters' do
+    task2 = TestTask.new
+
+    task2_ref = ForemanDeployments::TaskReference.new('task2', 'resource.id')
+    task2_ref.task = task2
+
+    task1 = TestTask.new(
+      :test_resource_ids => [task2_ref]
+    )
+
+    definition = ForemanDeployments::StackDefinition.new(
+      'task1' => task1,
+      'task2' => task2
+    )
+    definition.accept(@visitor)
+
+    assert_equal(1, task1.parameters['test_resources'].size)
+    assert_equal('resource', task1.parameters['test_resources'][0].output_key)
+  end
+
+  test 'it does not change parameters that are not references' do
+    params = {
+      'test_resource_id' => 1,
+      'test_resource_ids' => [1, 2]
+    }
+    task1 = TestTask.new(params)
+
+    definition = ForemanDeployments::StackDefinition.new(
+      'task1' => task1
+    )
+    definition.accept(@visitor)
+
+    assert_equal(params, task1.parameters)
+  end
+end

data/test/unit/lib/validation/validation_result_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+class ValidationResultTest < ActiveSupport::TestCase
+  describe 'valid?' do
+    test 'returns true when there are no messages' do
+      result = ForemanDeployments::Validation::ValidationResult.new
+      assert result.valid?
+    end
+
+    test 'returns false when there are some messages' do
+      result = ForemanDeployments::Validation::ValidationResult.new([
+        'Some error message'
+      ])
+      refute result.valid?
+    end
+  end
+
+  describe 'to_s' do
+    test 'is empty for valid results' do
+      result = ForemanDeployments::Validation::ValidationResult.new
+      assert_equal('', result.to_s)
+    end
+
+    test 'contains messages for the invalid results' do
+      result = ForemanDeployments::Validation::ValidationResult.new([
+        'Some error',
+        'Another error'
+      ])
+      assert_equal("Some error\nAnother error", result.to_s)
+    end
+
+    test 'contains messages for the invalid results stored in hashes' do
+      result = ForemanDeployments::Validation::ValidationResult.new(
+        'e1' => 'Some error',
+        'e2' => 'Another error'
+      )
+      assert_equal("e1: Some error\ne2: Another error", result.to_s)
+    end
+  end
+end