foreman_deployments 0.0.1

data/test/unit/lib/inputs/value_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+class ValueTest < ActiveSupport::TestCase
+  setup do
+    @input = ForemanDeployments::Inputs::Value.new(
+      'description' => 'Some description',
+      'default' => 123
+    )
+  end
+
+  test 'description' do
+    assert_equal('Some description', @input.description)
+  end
+
+  describe 'configured' do
+    test 'configured provides default when no custom value is set' do
+      assert_equal(123, @input.configured)
+    end
+
+    test 'configured provides custom value if it was set' do
+      @input.configure(456)
+      assert_equal(456, @input.configured)
+    end
+  end
+
+  describe 'to_hash' do
+    setup do
+      @expected = {
+        '_type' => 'input',
+        '_name' => 'Value',
+        'description' => 'Some description',
+        'default' => 123,
+        'value' => nil
+      }
+    end
+
+    test 'contains all the information' do
+      assert_equal(@expected, @input.to_hash)
+    end
+
+    test 'reflects configuration' do
+      @expected['value'] = 456
+      @input.configure(456)
+      assert_equal(@expected, @input.to_hash)
+    end
+  end
+end

data/test/unit/lib/registry_test.rb

@@ -0,0 +1,117 @@
+require 'test_helper'
+
+class RegistryTest < ActiveSupport::TestCase
+  class Task < ForemanDeployments::Tasks::BaseDefinition; end
+  class Input < ForemanDeployments::Inputs::BaseInputDefinition; end
+
+  def named(klass, name)
+    klass.stubs(:tag_name).returns(name)
+    klass
+  end
+
+  def task_named(name)
+    named(Task, name)
+  end
+
+  def input_named(name)
+    named(Input, name)
+  end
+
+  setup do
+    @register = ForemanDeployments::Registry.new
+  end
+
+  test 'it does not contain any tasks by default' do
+    assert_equal({}, @register.available_tasks)
+  end
+
+  test 'it raises exception for invalid type' do
+    e = assert_raises ForemanDeployments::Registry::TypeException do
+      @register.register('some_type', task_named('task1'))
+    end
+    assert_match('Type needs to be one of: task, input', e.message)
+  end
+
+  test 'it clears registeretd items' do
+    @register.register_task(task_named(:task1))
+    @register.register_task(task_named(:task2))
+    @register.register_input(input_named(:input1))
+    @register.clear!
+    assert_equal({}, @register.available_tasks)
+    assert_equal({}, @register.available_inputs)
+  end
+
+  describe 'tasks' do
+    test 'it registers a task' do
+      @register.register_task(task_named('task1'))
+      assert_equal({ 'task1' => 'RegistryTest::Task' }, @register.available_tasks)
+    end
+
+    test 'it registers a task with a symbol tag' do
+      @register.register_task(task_named(:task1))
+      @register.register_task(task_named(:task2))
+      assert_equal({ 'task1' => 'RegistryTest::Task', 'task2' => 'RegistryTest::Task' }, @register.available_tasks)
+    end
+
+    test 'it does not allow to register a task with empty tag' do
+      assert_raises ForemanDeployments::Registry::TypeException do
+        @register.register_task(task_named(''))
+      end
+    end
+
+    test 'it does not allow to register a task with nil tag' do
+      assert_raises ForemanDeployments::Registry::TypeException do
+        @register.register_task(task_named(nil))
+      end
+    end
+
+    test 'it does not allow to register a task with invalid name' do
+      assert_raises ForemanDeployments::Registry::TypeException do
+        @register.register_task(task_named('[]'))
+      end
+    end
+
+    test 'it does not allow to register a class that is not child of ForemanDeployments::Tasks::BaseDefinition' do
+      assert_raises ForemanDeployments::Registry::TypeException do
+        @register.register_task(Object)
+      end
+    end
+  end
+
+  describe 'inputs' do
+    test 'it registers an input' do
+      @register.register_input(input_named('input1'))
+      assert_equal({ 'input1' => 'RegistryTest::Input' }, @register.available_inputs)
+    end
+
+    test 'it registers an input with a symbol tag' do
+      @register.register_input(input_named(:input1))
+      @register.register_input(input_named(:input2))
+      assert_equal({ 'input1' => 'RegistryTest::Input', 'input2' => 'RegistryTest::Input' }, @register.available_inputs)
+    end
+
+    test 'it does not allow to register an input with empty tag' do
+      assert_raises ForemanDeployments::Registry::TypeException do
+        @register.register_input(input_named(''))
+      end
+    end
+
+    test 'it does not allow to register an input with nil tag' do
+      assert_raises ForemanDeployments::Registry::TypeException do
+        @register.register_input(input_named(nil))
+      end
+    end
+
+    test 'it does not allow to register an input with invalid name' do
+      assert_raises ForemanDeployments::Registry::TypeException do
+        @register.register_input(input_named('[]'))
+      end
+    end
+
+    test 'it does not allow to register a class that is not child of ForemanDeployments::Inputs::BaseInputDefinition' do
+      assert_raises ForemanDeployments::Registry::TypeException do
+        @register.register_input(Object)
+      end
+    end
+  end
+end

data/test/unit/lib/stack_definition_test.rb

@@ -0,0 +1,54 @@
+require 'test_helper'
+
+class StackDefinitionTest < ActiveSupport::TestCase
+  setup do
+    @tasks = {
+      'task1' => ForemanDeployments::Tasks::BaseDefinition.new,
+      'task2' => ForemanDeployments::Tasks::BaseDefinition.new
+    }
+  end
+
+  describe 'tasks' do
+    test 'returns empty hash by default' do
+      definition = ForemanDeployments::StackDefinition.new
+      assert_equal({}, definition.tasks)
+    end
+
+    test 'it returns tasks' do
+      definition = ForemanDeployments::StackDefinition.new(@tasks)
+
+      assert_equal(2, definition.tasks.count)
+      assert_equal(@tasks['task1'], definition.tasks['task1'])
+      assert_equal(@tasks['task2'], definition.tasks['task2'])
+    end
+
+    test 'it sets ids to tasks' do
+      definition = ForemanDeployments::StackDefinition.new(@tasks)
+
+      assert_equal('task1', definition.tasks['task1'].task_id)
+      assert_equal('task2', definition.tasks['task2'].task_id)
+    end
+  end
+
+  describe 'accept' do
+    test 'it calls visit on the visitor with self' do
+      definition = ForemanDeployments::StackDefinition.new
+
+      visitor = mock
+      visitor.expects(:visit).with(definition).once
+
+      definition.accept(visitor)
+    end
+
+    test 'it calls accept on all tasks' do
+      definition = ForemanDeployments::StackDefinition.new(@tasks)
+
+      visitor = mock
+      visitor.stubs(:visit)
+
+      definition.tasks['task1'].expects(:accept).with(visitor).once
+      definition.tasks['task2'].expects(:accept).with(visitor).once
+      definition.accept(visitor)
+    end
+  end
+end

data/test/unit/lib/stack_parser_test.rb

@@ -0,0 +1,129 @@
+require 'test_helper'
+
+class StackParserTest < ActiveSupport::TestCase
+  class Vulnerable
+  end
+
+  class TestTask < ForemanDeployments::Tasks::BaseDefinition; end
+  class TestInput < ForemanDeployments::Inputs::BaseInputDefinition; end
+
+  def assert_stack_invalid
+    e = assert_raises ForemanDeployments::StackParseException do
+      yield
+    end
+    assert_match(/Stack definition is invalid/, e.message)
+  end
+
+  setup do
+    @registry = ForemanDeployments::Registry.new
+    @parser = ForemanDeployments::StackParser.new(@registry)
+  end
+
+  test 'it raises exception when the stack is not valid yaml hash' do
+    assert_stack_invalid do
+      @parser.parse('This is not a valid stack')
+    end
+  end
+
+  test 'it raises exception when the input is not string' do
+    assert_stack_invalid do
+      @parser.parse(123)
+    end
+  end
+
+  test 'it raises exception when the input is nil' do
+    assert_stack_invalid do
+      @parser.parse(nil)
+    end
+  end
+
+  test 'it raises exception when the input is empty string' do
+    assert_stack_invalid do
+      @parser.parse('')
+    end
+  end
+
+  test 'it raises exception when the stack contains references to unknown tasks' do
+    stack = [
+      'FirstRun: !task:Unknown',
+      '  parameters:',
+      '    host_id: 1'
+    ].join("\n")
+    e = assert_raises ForemanDeployments::UnknownTaskException do
+      @parser.parse(stack)
+    end
+    assert_match(/Unknown stack task Unknown/, e.message)
+  end
+
+  test 'it does not allow creation of custom objects' do
+    stack = [
+      'SatelliteStack: !ruby/object:Vulnerable',
+      '  name: Satellite'
+    ].join("\n")
+    e = assert_raises ForemanDeployments::UnknownYAMLTagException do
+      @parser.parse(stack)
+    end
+    assert_match(/Unknown YAML tag ruby\/object:Vulnerable/, e.message)
+  end
+
+  test 'it returns instance of StackDefinition' do
+    @registry.register_task(TestTask)
+
+    stack = [
+      'FirstRun: !task:TestTask',
+      '  parameters:',
+      '    host_id: 1'
+    ].join("\n")
+
+    stack_definition = @parser.parse(stack)
+    assert_equal(ForemanDeployments::StackDefinition, stack_definition.class)
+  end
+
+  test 'it parses the stack' do
+    @registry.register_task(TestTask)
+    @registry.register_input(TestInput)
+
+    stack = [
+      'FirstRun: !task:TestTask',
+      '  parameters:',
+      '    host_id: 1',
+      'SecondRun: !task:TestTask',
+      '  parameters:',
+      '    name: !input:TestInput'
+    ].join("\n")
+
+    stack_definition = @parser.parse(stack)
+
+    task_definition = stack_definition.tasks['FirstRun']
+    assert_equal(StackParserTest::TestTask, task_definition.class)
+    assert_equal('FirstRun', task_definition.task_id)
+    assert_equal({ 'parameters' => { 'host_id' => 1 } }, task_definition.parameters)
+
+    task_definition = stack_definition.tasks['SecondRun']
+    assert_equal(StackParserTest::TestTask, task_definition.class)
+    assert_equal('SecondRun', task_definition.task_id)
+    assert_equal(StackParserTest::TestInput, task_definition.parameters['parameters']['name'].class)
+  end
+
+  test 'it parses references in a stack' do
+    @registry.register_task(TestTask)
+
+    stack = [
+      'DbServerHost: !task:TestTask',
+      'FirstRun: !task:TestTask',
+      '  parameters:',
+      '    host_id: !reference',
+      "      object: 'DbServerHost'",
+      "      field: 'result.id'"
+    ].join("\n")
+    stack_definition = @parser.parse(stack)
+
+    assert_equal(StackParserTest::TestTask, stack_definition.tasks['FirstRun'].class)
+
+    reference = stack_definition.tasks['FirstRun'].parameters['parameters']['host_id']
+    assert_equal(ForemanDeployments::TaskReference, reference.class)
+    assert_equal('DbServerHost', reference.task_id)
+    assert_equal(stack_definition.tasks['DbServerHost'], reference.task)
+    assert_equal('result.id', reference.output_key)
+  end
+end

data/test/unit/lib/task_reference_test.rb

@@ -0,0 +1,63 @@
+require 'test_helper'
+
+class TaskReferenceTest < ActiveSupport::TestCase
+  test 'referenced task can be optionally set in the constructor' do
+    task = mock
+    ref = ForemanDeployments::TaskReference.new('task', 'resource.id', task)
+    assert_equal(task, ref.task)
+  end
+
+  describe 'dereference' do
+    test 'it dereferences hash' do
+      ref = ForemanDeployments::TaskReference.new('task', 'resource.id')
+      value = ref.dereference('resource' => { 'id' => 123 })
+      assert_equal(123, value)
+    end
+
+    test 'it dereferences object' do
+      obj = mock
+      obj.stubs(:id).returns(123)
+
+      ref = ForemanDeployments::TaskReference.new('task', 'resource.id')
+      value = ref.dereference('resource' => obj)
+      assert_equal(123, value)
+    end
+
+    test 'it return nil when the key does not exist' do
+      ref = ForemanDeployments::TaskReference.new('task', 'resource.unknown')
+      value = ref.dereference('resource' => {})
+      assert_equal(nil, value)
+    end
+
+    test 'it return nil when the method does not exist' do
+      ref = ForemanDeployments::TaskReference.new('task', 'resource.unknown')
+      value = ref.dereference('resource' => Object.new)
+      assert_equal(nil, value)
+    end
+
+    test 'it dereferences one item path' do
+      obj = mock
+
+      ref = ForemanDeployments::TaskReference.new('task', 'resource')
+      value = ref.dereference('resource' => obj)
+      assert_equal(obj, value)
+    end
+
+    test 'it dereferences one item path defined by symbol' do
+      obj = mock
+
+      ref = ForemanDeployments::TaskReference.new('task', :resource)
+      value = ref.dereference('resource' => obj)
+      assert_equal(obj, value)
+    end
+  end
+
+  test 'accept calls visit on the visitor with self' do
+    ref = ForemanDeployments::TaskReference.new('task', 'resource.id')
+
+    visitor = mock
+    visitor.expects(:visit).with(ref).once
+
+    ref.accept(visitor)
+  end
+end

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

@@ -0,0 +1,137 @@
+require 'test_helper'
+
+class BaseDefinitionTest < ActiveSupport::TestCase
+  describe 'task_id' do
+    test "it's nil by default" do
+      assert_equal(nil, ForemanDeployments::Tasks::BaseDefinition.new.task_id)
+    end
+
+    test 'it enables setting an id' do
+      task = ForemanDeployments::Tasks::BaseDefinition.new
+      task.task_id = :some_task
+      assert_equal(:some_task, task.task_id)
+    end
+  end
+
+  test 'it returns parameters' do
+    expected_params = {
+      'a' => 1,
+      'b' => 2
+    }
+    task = ForemanDeployments::Tasks::BaseDefinition.new(expected_params)
+    assert_equal(expected_params, task.parameters)
+  end
+
+  describe 'plan' do
+    let(:task_params) { { 'params' => true } }
+    let(:dynflow_action) { mock }
+    let(:parent_task) do
+      parent_task = mock
+      parent_task.expects(:plan_action).with(dynflow_action, task_params).once.returns(dynflow_action)
+      parent_task
+    end
+    let(:task) do
+      task = ForemanDeployments::Tasks::BaseDefinition.new(task_params)
+      task.stubs(:dynflow_action).returns(dynflow_action)
+      task
+    end
+
+    test 'plans action returned from dynflow_action' do
+      task.plan(parent_task)
+    end
+
+    test 'plans the action only once' do
+      task.plan(parent_task)
+      task.plan(parent_task)
+    end
+  end
+
+  test 'validate raises not implemented exception' do
+    assert_raises NotImplementedError do
+      ForemanDeployments::Tasks::BaseDefinition.new.validate
+    end
+  end
+
+  test 'dynflow_action raises not implemented exception' do
+    assert_raises NotImplementedError do
+      ForemanDeployments::Tasks::BaseDefinition.new.dynflow_action
+    end
+  end
+
+  describe 'configuration' do
+    setup do
+      @parameters1 = {
+        'count' => 1,
+        'should_not' => 'be_touched',
+        'parameters' => {
+          'a' => 1,
+          'b' => 2
+        }
+      }
+      @parameters2 = {
+        'count' => 2,
+        'parameters' => {
+          'a' => 1,
+          'c' => 3
+        }
+      }
+    end
+
+    test 'configure deep merges the parameters' do
+      task = ForemanDeployments::Tasks::BaseDefinition.new
+
+      task.configure(@parameters1)
+      task.configure(@parameters2)
+      assert_equal(@parameters2, task.configuration)
+    end
+
+    test 'merge_configuration deep merges the parameters' do
+      task = ForemanDeployments::Tasks::BaseDefinition.new
+
+      expected_params = {
+        'count' => 2,
+        'should_not' => 'be_touched',
+        'parameters' => {
+          'a' => 1,
+          'b' => 2,
+          'c' => 3
+        }
+      }
+
+      task.configure(@parameters1)
+      task.merge_configuration(@parameters2)
+      assert_equal(expected_params, task.configuration)
+    end
+  end
+
+  describe 'accept' do
+    test 'it calls visit on the visitor with self' do
+      definition = ForemanDeployments::Tasks::BaseDefinition.new
+
+      visitor = mock
+      visitor.expects(:visit).with(definition).once
+
+      definition.accept(visitor)
+    end
+
+    test 'it calls visit on parameters' do
+      visitable1 = mock
+      visitable2 = mock
+
+      definition = ForemanDeployments::Tasks::BaseDefinition.new(
+        :params => {
+          :first => 1,
+          :second => visitable1,
+          :third => [1, 2, visitable2]
+        }
+      )
+
+      visitor = mock
+      visitor.expects(:visit).with(definition).once
+      visitable1.expects(:accept).with(visitor).once
+      visitable2.expects(:accept).with(visitor).once
+
+      definition.accept(visitor)
+    end
+  end
+end