foreman_deployments 0.0.1

data/test/functional/api/v2/stacks_controller_test.rb

@@ -0,0 +1,140 @@
+require 'test_plugin_helper'
+
+class ForemanDeployments::Api::V2::StacksControllerTest < ActionController::TestCase
+  include RegistryStub
+
+  class FakeTask < ForemanDeployments::Tasks::BaseDefinition
+  end
+
+  setup do
+    @definition = [
+      'FirstRun: !task:FakeTask',
+      '  parameters:',
+      '    host_id: 1'
+    ].join("\n")
+
+    @registry = stub_registry
+    @registry.register_task(FakeTask)
+  end
+
+  describe 'importing stack' do
+    test 'should import stack' do
+      assert_difference('ForemanDeployments::Stack.count', 1) do
+        post :create,  :stack => { :name => 'Test stack', :definition => @definition }
+      end
+      assert_response :success
+
+      parsed_response = JSON.parse(response.body)
+      assert_equal('Test stack', parsed_response['name'])
+    end
+
+    test 'should complain on invalid stack' do
+      @registry.clear!
+      assert_difference('ForemanDeployments::Stack.count', 0) do
+        post :create,  :stack => { :name => 'Test stack', :definition => @definition }
+      end
+      assert_response :unprocessable_entity
+
+      parsed_response = JSON.parse(response.body)
+      assert_match('Unknown stack task FakeTask', parsed_response['error']['message'])
+    end
+  end
+
+  describe 'updating stacks' do
+    setup do
+      @updated_definition = [
+        'AnotherRun: !task:FakeTask'
+      ].join("\n")
+      @stack = ForemanDeployments::Stack.create(:name => 'Test Stack', :definition => @definition)
+    end
+
+    test 'stacks without configuration are editable' do
+      put :update, :id => @stack.id, :stack => { :name => 'Updated name', :definition => @updated_definition }
+      assert_response :success
+
+      @stack.reload
+      assert_equal('Updated name', @stack.name)
+      assert_equal(@updated_definition, @stack.definition)
+    end
+
+    describe 'with saved configuration' do
+      setup do
+        @stack.configurations.create!
+      end
+
+      test 'it allows to update attributes other than definition' do
+        put :update, :id => @stack.id, :stack => { :name => 'Updated name' }
+        assert_response :success
+
+        @stack.reload
+        assert_equal('Updated name', @stack.name)
+      end
+
+      test 'it fails if the definition would be updated' do
+        put :update, :id => @stack.id, :stack => { :definition => @updated_definition }
+        assert_response :unprocessable_entity
+
+        parsed_response = JSON.parse(response.body)
+        assert_match('Can\'t update stack that has been configured', parsed_response['error'])
+
+        @stack.reload
+        assert_equal('Test Stack', @stack.name)
+        assert_equal(@definition, @stack.definition)
+      end
+    end
+
+    test 'it fails if the new stack definition is invalid' do
+      @registry.clear!
+
+      put :update, :id => @stack.id, :stack => { :definition => @updated_definition }
+      assert_response :unprocessable_entity
+
+      parsed_response = JSON.parse(response.body)
+      assert_match('Unknown stack task FakeTask', parsed_response['error']['message'])
+
+      @stack.reload
+      assert_equal('Test Stack', @stack.name)
+      assert_equal(@definition, @stack.definition)
+    end
+  end
+
+  describe 'listing stacks' do
+    setup do
+      @stack1 = FactoryGirl.create(:stack,
+                                   :organizations => [taxonomies(:organization1)],
+                                   :locations => [taxonomies(:location1)]
+      )
+      @stack2 = FactoryGirl.create(:stack,
+                                   :organizations => [taxonomies(:organization1)],
+                                   :locations => [taxonomies(:location2)]
+      )
+      @stack3 = FactoryGirl.create(:stack,
+                                   :organizations => [taxonomies(:organization2)],
+                                   :locations => [taxonomies(:location2)]
+      )
+    end
+
+    test 'it lists available stacks' do
+      get :index
+      assert_response :success
+    end
+
+    test 'should get stacks for location only' do
+      get :index, :location_id => taxonomies(:location2).id
+      assert_response :success
+      assert_equal [@stack2, @stack3], assigns(:stacks)
+    end
+
+    test 'should get stacks for organization only' do
+      get :index, :organization_id => taxonomies(:organization1).id
+      assert_response :success
+      assert_equal [@stack1, @stack2], assigns(:stacks)
+    end
+
+    test 'should get stacks for both location and organization' do
+      get :index, :organization_id => taxonomies(:organization1).id, :location_id => taxonomies(:location1).id
+      assert_response :success
+      assert_equal [@stack1], assigns(:stacks)
+    end
+  end
+end

data/test/test_plugin_helper.rb

@@ -0,0 +1,14 @@
+# This calls the main test_helper in Foreman-core
+require 'test_helper'
+
+module RegistryStub
+  def stub_registry
+    registry = ForemanDeployments::Registry.new
+    ForemanDeployments.stubs(:registry).returns(registry)
+    registry
+  end
+end
+
+# Add plugin to FactoryGirl's paths
+FactoryGirl.definition_file_paths << File.join(File.dirname(__FILE__), 'factories')
+FactoryGirl.reload

data/test/unit/lib/config/array_test.rb

@@ -0,0 +1,217 @@
+require 'test_helper'
+
+class ArrayTest < ActiveSupport::TestCase
+  describe 'merge_configuration' do
+    setup do
+      @array = ForemanDeployments::Config::Array[nil, nil]
+    end
+
+    test 'can set values to empty slots' do
+      @array.merge_configuration([1, 2])
+      assert_equal([1, 2], @array.configured)
+    end
+
+    test 'can be configured with shorter array' do
+      @array.merge_configuration([1])
+      assert_equal([1, nil], @array.configured)
+    end
+
+    test 'can be configured with hash' do
+      @array.merge_configuration(1 => :b)
+      assert_equal([nil, :b], @array.configured)
+    end
+
+    test 'can be configured with hash using string keys' do
+      @array.merge_configuration('1' => :b)
+      assert_equal([nil, :b], @array.configured)
+    end
+
+    test 'raises exception when configured with value other than hash or array' do
+      e = assert_raises ForemanDeployments::Config::InvalidValueException do
+        @array.merge_configuration(1)
+      end
+      assert_match("Unexpected type 'Fixnum', only hash or array is accepted", e.message)
+      assert_equal([nil, nil], @array.configured)
+    end
+
+    test 'raises exception when configured with hash using non-numeric string keys' do
+      e = assert_raises ForemanDeployments::Config::InvalidValueException do
+        @array.merge_configuration('abc' => :b)
+      end
+      assert_match("Key 'abc' isn't numeric value", e.message)
+      assert_equal([nil, nil], @array.configured)
+    end
+
+    test 'can delete value with setting nil' do
+      @array.configure([1, 2])
+      @array.merge_configuration(1 => nil)
+      assert_equal([1, nil], @array.configured)
+    end
+
+    test 'calls configure on configurable items' do
+      configurable = mock
+      configurable.expects(:merge_configuration).with(123).once
+      array = ForemanDeployments::Config::Array[configurable]
+      array.merge_configuration([123])
+    end
+
+    test 'keeps preconfigured values untouched' do
+      @array.configure([1, 2])
+      assert_equal([nil, nil], @array)
+    end
+
+    test 'raises exception when extra value is added' do
+      e = assert_raises ForemanDeployments::Config::InvalidValueException do
+        @array.merge_configuration([1, 2, 3])
+      end
+      assert_match("Can't configure items outside the range", e.message)
+      assert_equal([nil, nil], @array.configured)
+    end
+
+    test 'raises exception when a value would be overwritten' do
+      array = ForemanDeployments::Config::Array[nil, 1]
+      e = assert_raises ForemanDeployments::Config::InvalidValueException do
+        array.merge_configuration([1, 2])
+      end
+      assert_match("You can't override values hardcoded in the stack definition", e.message)
+      assert_equal([1, 1], array.configured)
+    end
+  end
+
+  describe 'configure' do
+    setup do
+      @array = ForemanDeployments::Config::Array[nil, nil]
+    end
+
+    test 'can set values to empty slots' do
+      @array.configure([1, 2])
+      assert_equal([1, 2], @array.configured)
+    end
+
+    test 'overrides the config when called twice' do
+      @array.configure([1, 2])
+      @array.configure([3])
+      assert_equal([3, nil], @array.configured)
+    end
+
+    test 'can be configured with shorter array' do
+      @array.configure([1])
+      assert_equal([1, nil], @array.configured)
+    end
+
+    test 'can be configured with hash' do
+      @array.configure(1 => :b)
+      assert_equal([nil, :b], @array.configured)
+    end
+
+    test 'can be configured with hash using string keys' do
+      @array.configure('1' => :b)
+      assert_equal([nil, :b], @array.configured)
+    end
+
+    test 'raises exception when configured with value other than hash or array' do
+      e = assert_raises ForemanDeployments::Config::InvalidValueException do
+        @array.configure(1)
+      end
+      assert_match("Unexpected type 'Fixnum', only hash or array is accepted", e.message)
+      assert_equal([nil, nil], @array.configured)
+    end
+
+    test 'raises exception when configured with hash using non-numeric string keys' do
+      e = assert_raises ForemanDeployments::Config::InvalidValueException do
+        @array.configure('abc' => :b)
+      end
+      assert_match("Key 'abc' isn't numeric value", e.message)
+      assert_equal([nil, nil], @array.configured)
+    end
+
+    test 'calls configure on configurable items' do
+      configurable = mock
+      configurable.expects(:configure).with(123).once
+      array = ForemanDeployments::Config::Array[configurable]
+      array.configure([123])
+    end
+
+    test 'keeps preconfigured values untouched' do
+      @array.configure([1, 2])
+      assert_equal([nil, nil], @array)
+    end
+
+    test 'raises exception when extra value is added' do
+      e = assert_raises ForemanDeployments::Config::InvalidValueException do
+        @array.configure([1, 2, 3])
+      end
+      assert_match("Can't configure items outside the range", e.message)
+      assert_equal([nil, nil], @array.configured)
+    end
+
+    test 'raises exception when a value would be overwritten' do
+      array = ForemanDeployments::Config::Array[nil, 1]
+      e = assert_raises ForemanDeployments::Config::InvalidValueException do
+        array.configure([1, 2])
+      end
+      assert_match("You can't override values hardcoded in the stack definition", e.message)
+      assert_equal([1, 1], array.configured)
+    end
+  end
+
+  describe 'configuration' do
+    test 'returns nil by default' do
+      array = ForemanDeployments::Config::Array[:a, nil]
+      assert_nil(array.configuration)
+    end
+
+    test 'returns nil when the config was erased' do
+      array = ForemanDeployments::Config::Array[:a, nil]
+      array.configure(1 => 2)
+      array.configure(1 => nil)
+      assert_nil(array.configuration)
+    end
+
+    test 'returns only configured values' do
+      array = ForemanDeployments::Config::Array[nil, :b]
+      array.configure([:a])
+      assert_equal({ 0 => :a }, array.configuration)
+    end
+
+    test 'returns configured values from inner items' do
+      configurable = mock
+      configurable.stubs(:configuration).returns(123)
+
+      array = ForemanDeployments::Config::Array[nil, configurable]
+      assert_equal({ 1 => 123 }, array.configuration)
+    end
+  end
+
+  describe 'configured' do
+    test 'returns preconfigured values mixed with the configuration' do
+      array = ForemanDeployments::Config::Array[:a, nil]
+      array.configure(1 => :b)
+      assert_equal([:a, :b], array.configured)
+    end
+
+    test 'returns values from inner items' do
+      configurable = mock
+      configurable.stubs(:configured).returns(123)
+
+      array = ForemanDeployments::Config::Array[:a, configurable]
+      assert_equal([:a, 123], array.configured)
+    end
+  end
+
+  describe 'transform!' do
+    setup do
+      @array = ForemanDeployments::Config::Array[1, 2, nil]
+      @array.configure(2 => :value)
+      @array.transform!(&:to_s)
+    end
+
+    test 'transforms values' do
+      assert_equal(['1', '2', ''], @array)
+    end
+
+    test 'keeps the configuration' do
+      assert_equal({ 2 => :value }, @array.configuration)
+    end
+  end
+end

data/test/unit/lib/config/configurator_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+
+class ConfiguratorTest < ActiveSupport::TestCase
+  class TestTask < ForemanDeployments::Tasks::BaseDefinition; end
+
+  setup do
+    @task1 = TestTask.new
+    @task2 = TestTask.new
+
+    @stack_definition = ForemanDeployments::StackDefinition.new(
+      'task1' => @task1,
+      'task2' => @task2
+    )
+
+    @config = mock
+    @config.stubs(:get_config_for).with(@task1).returns('key1' => 'value1')
+    @config.stubs(:get_config_for).with(@task2).returns('key2' => 'value2')
+
+    @config2 = mock
+    @config2.stubs(:get_config_for).with(@task1).returns('key2' => 'value2')
+    @config2.stubs(:get_config_for).with(@task2).returns('key2' => 'updated_value2', 'key3' => 'value3')
+
+    @configurator = ForemanDeployments::Config::Configurator.new(@stack_definition)
+  end
+
+  describe 'configure' do
+    it 'configures the stack' do
+      @configurator.configure(@config)
+
+      assert_equal({ 'key1' => 'value1' }, @task1.configuration)
+      assert_equal({ 'key2' => 'value2' }, @task2.configuration)
+    end
+
+    it 'overwrites the previous config' do
+      @task1.configure('key1' => 'previous_value1', 'some_key' => 'value_value')
+      @task2.configure('key2' => 'previous_value2', 'some_key' => 'value_value')
+
+      @configurator.configure(@config)
+
+      assert_equal({ 'key1' => 'value1' }, @task1.configuration)
+      assert_equal({ 'key2' => 'value2' }, @task2.configuration)
+    end
+  end
+
+  describe 'merge' do
+    it 'loads the config and merges the update' do
+      @configurator.merge(@config, @config2)
+
+      assert_equal({ 'key1' => 'value1', 'key2' => 'value2' }, @task1.configuration)
+      assert_equal({ 'key2' => 'updated_value2', 'key3' => 'value3' }, @task2.configuration)
+    end
+  end
+
+  describe 'dump' do
+    it 'saves the stack configuration' do
+      @task1.stubs(:configuration).returns(:a => 1)
+      @task2.stubs(:configuration).returns(:b => 2)
+
+      config = ForemanDeployments::Configuration.new
+      @configurator.dump(config)
+
+      assert_equal({ :a => 1 }, config.get_config_for(@task1))
+      assert_equal({ :b => 2 }, config.get_config_for(@task2))
+    end
+  end
+end

data/test/unit/lib/config/hash_test.rb

@@ -0,0 +1,178 @@
+require 'test_helper'
+
+class HashTest < ActiveSupport::TestCase
+  describe 'merge_configuration' do
+    test 'can set values' do
+      hash = ForemanDeployments::Config::Hash[]
+      hash.merge_configuration(:b => 3)
+      assert_equal({ 'b' => 3 }, hash.configured)
+    end
+
+    test 'calls configure on configurable items' do
+      configurable = mock
+      configurable.expects(:merge_configuration).with(123).once
+
+      hash = ForemanDeployments::Config::Hash[:a => configurable]
+      hash.merge_configuration(:a => 123)
+    end
+
+    test 'can delete value with setting nil' do
+      hash = ForemanDeployments::Config::Hash[]
+      hash.merge_configuration(:b => 2)
+      hash.merge_configuration(:b => nil)
+      assert_equal({}, hash.configured)
+    end
+
+    test 'keeps preconfigured values untouched' do
+      hash = ForemanDeployments::Config::Hash[:a => 1]
+      hash.merge_configuration(:b => 2)
+      assert_equal({ :a => 1 }, hash)
+    end
+
+    test 'can add additional preconfigured hashses' do
+      hash = ForemanDeployments::Config::Hash[]
+      hash.merge_configuration(:a => { :b => 1 })
+
+      assert_equal({}, hash['a'])
+      assert_equal(ForemanDeployments::Config::Hash, hash['a'].class)
+    end
+
+    test 'can add additional preconfigured arrays' do
+      hash = ForemanDeployments::Config::Hash[]
+      hash.merge_configuration(:a => [:b, :c])
+
+      assert_equal([nil, nil], hash['a'])
+      assert_equal(ForemanDeployments::Config::Array, hash['a'].class)
+    end
+
+    test 'raises exception when a value would be overwritten' do
+      hash = ForemanDeployments::Config::Hash[:a => 1]
+      e = assert_raises ForemanDeployments::Config::InvalidValueException do
+        hash.merge_configuration(:a => 2)
+      end
+      assert_match("You can't override values hardcoded in the stack definition", e.message)
+      assert_equal({ 'a' => 1 }, hash.configured)
+    end
+  end
+
+  describe 'configure' do
+    test 'can set values' do
+      hash = ForemanDeployments::Config::Hash[]
+      hash.configure(:b => 3)
+      assert_equal({ 'b' => 3 }, hash.configured)
+    end
+
+    test 'calls configure on configurable items' do
+      configurable = mock
+      configurable.expects(:configure).with(123).once
+
+      hash = ForemanDeployments::Config::Hash[:a => configurable]
+      hash.configure(:a => 123)
+    end
+
+    test 'it overwrites previous config' do
+      hash = ForemanDeployments::Config::Hash[]
+      hash.configure(:b => 2)
+      hash.configure(:a => 1)
+      assert_equal({ 'a' => 1 }, hash.configured)
+    end
+
+    test 'keeps preconfigured values untouched' do
+      hash = ForemanDeployments::Config::Hash[:a => 1]
+      hash.configure(:b => 2)
+      assert_equal({ :a => 1 }, hash)
+    end
+
+    test 'can add additional preconfigured hashses' do
+      hash = ForemanDeployments::Config::Hash[]
+      hash.configure(:a => { :b => 1 })
+
+      assert_equal({}, hash['a'])
+      assert_equal(ForemanDeployments::Config::Hash, hash['a'].class)
+    end
+
+    test 'can add additional preconfigured arrays' do
+      hash = ForemanDeployments::Config::Hash[]
+      hash.configure(:a => [:b, :c])
+
+      assert_equal([nil, nil], hash['a'])
+      assert_equal(ForemanDeployments::Config::Array, hash['a'].class)
+    end
+
+    test 'raises exception when a value would be overwritten' do
+      hash = ForemanDeployments::Config::Hash[:a => 1]
+      e = assert_raises ForemanDeployments::Config::InvalidValueException do
+        hash.configure(:a => 2)
+      end
+      assert_match("You can't override values hardcoded in the stack definition", e.message)
+      assert_equal({ 'a' => 1 }, hash.configured)
+    end
+  end
+
+  describe 'configuration' do
+    test 'returns nil by default' do
+      hash = ForemanDeployments::Config::Hash[:a => 1]
+      assert_nil(hash.configuration)
+    end
+
+    test 'returns nil when the config was erased' do
+      hash = ForemanDeployments::Config::Hash[:a => 1]
+      hash.configure(:b => 2)
+      hash.configure(:b => nil)
+      assert_nil(hash.configuration)
+    end
+
+    test 'returns only configured values' do
+      hash = ForemanDeployments::Config::Hash[:a => 1]
+      hash.configure(:b => 2, :c => 3)
+      assert_equal({ 'b' => 2, 'c' => 3 }, hash.configuration)
+    end
+
+    test 'returns configured values from inner items' do
+      configurable = mock
+      configurable.stubs(:configuration).returns(123)
+
+      hash = ForemanDeployments::Config::Hash[:a => configurable]
+      hash.configure(:b => 2)
+      assert_equal({ 'a' => 123, 'b' => 2 }, hash.configuration)
+    end
+  end
+
+  describe 'configured' do
+    test 'returns preconfigured values mixed with the configuration' do
+      hash = ForemanDeployments::Config::Hash[:a => 1]
+      hash.configure(:b => 2)
+      assert_equal({ 'a' => 1, 'b' => 2 }, hash.configured)
+    end
+
+    test 'returns values from inner items' do
+      configurable = mock
+      configurable.stubs(:configured).returns('c' => 123)
+
+      hash = ForemanDeployments::Config::Hash[:a => configurable]
+      hash.configure(:b => 2)
+      assert_equal({ 'a' => { 'c' => 123 }, 'b' => 2 }, hash.configured)
+    end
+  end
+
+  describe 'transform!' do
+    test 'transforms values' do
+      hash = ForemanDeployments::Config::Hash['a' => 1, 'b' => 2]
+      hash.transform! { |key, val| [key, val * 2] }
+      assert_equal({ 'a' => 2, 'b' => 4 }, hash)
+    end
+
+    test 'enables to change the keys' do
+      hash = ForemanDeployments::Config::Hash['a' => 1, 'b' => 2]
+      hash.transform! { |key, val| [key * 2, val * 2] }
+      assert_equal({ 'aa' => 2, 'bb' => 4 }, hash)
+    end
+
+    test 'keeps the configuration' do
+      hash = ForemanDeployments::Config::Hash['a' => 1, 'b' => 2]
+      hash.configure('c' => 3)
+      hash.transform! { |key, val| [key, val * 2] }
+      assert_equal({ 'c' => 3 }, hash.configuration)
+    end
+  end
+end