foreman_ansible 6.2.0 → 6.3.0

data/test/factories/host_ansible_enhancements.rb

@@ -0,0 +1,23 @@
+FactoryBot.modify do
+  factory :host do
+    trait :with_ansible_roles do
+      transient do
+        roles_count { 2 }
+      end
+      after(:build) do |host, evaluator|
+        host.host_ansible_roles = FactoryBot.build_list(:host_ansible_role, evaluator.roles_count, host: host)
+      end
+    end
+  end
+
+  factory :hostgroup do
+    trait :with_ansible_roles do
+      transient do
+        roles_count { 2 }
+      end
+      after(:build) do |hostgroup, evaluator|
+        hostgroup.hostgroup_ansible_roles = FactoryBot.build_list(:hostgroup_ansible_role, evaluator.roles_count, hostgroup: hostgroup)
+      end
+    end
+  end
+end

data/test/foreman_ansible/helpers/ansible_roles_helper_test.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+class AnsibleRolesHelperTest < ActiveSupport::TestCase
+  include ForemanAnsible::AnsibleRolesHelper
+
+  describe '#role_attributes_for_roles_switcher' do
+    let(:hg_with_roles) { FactoryBot.create(:hostgroup, :with_ansible_roles) }
+
+    context 'with hostgroup' do
+      let(:child) { FactoryBot.build(:hostgroup, :with_ansible_roles, parent: hg_with_roles) }
+
+      it 'show inherited and positioned own roles' do
+        role_attributes = role_attributes_for_roles_switcher(child)
+        expected_ids = hg_with_roles.ansible_roles.pluck(:id) + child.hostgroup_ansible_roles.map(&:ansible_role_id)
+        assert_equal(expected_ids, role_attributes.map { |ra| ra[:id] })
+      end
+
+      it 'includes inherited roles just once' do
+        child.host_ansible_roles << FactoryBot.build(:hostgroup_ansible_role, hostgroup: child, ansible_role: hg_with_roles.ansible_roles.first)
+        role_attributes = role_attributes_for_roles_switcher(child)
+        expected_ids = hg_with_roles.ansible_roles.pluck(:id) + child.hostgroup_ansible_roles.map(&:ansible_role_id)
+        assert_equal(expected_ids.uniq, role_attributes.map { |ra| ra[:id] })
+      end
+    end
+
+    context 'with host' do
+      let(:host_new) { FactoryBot.build(:host, :with_ansible_roles, hostgroup: hg_with_roles) }
+
+      it 'show inherited and positioned own roles' do
+        role_attributes = role_attributes_for_roles_switcher(host_new)
+        expected_ids = hg_with_roles.ansible_roles.pluck(:id) + host_new.host_ansible_roles.map(&:ansible_role_id)
+        assert_equal(expected_ids, role_attributes.map { |ra| ra[:id] })
+      end
+
+      it 'includes inherited roles just once' do
+        host_new.host_ansible_roles << FactoryBot.build(:host_ansible_role, host: host_new, ansible_role: hg_with_roles.ansible_roles.first)
+        role_attributes = role_attributes_for_roles_switcher(host_new)
+        expected_ids = hg_with_roles.ansible_roles.pluck(:id) + host_new.host_ansible_roles.map(&:ansible_role_id)
+        assert_equal(expected_ids.uniq, role_attributes.map { |ra| ra[:id] })
+      end
+    end
+  end
+end

data/test/functional/ansible_variables_controller_test.rb

@@ -34,21 +34,6 @@ class AnsibleVariablesControllerTest < ActionController::TestCase
     assert_redirected_to ansible_variables_url
   end
 
-  test 'should show import page' do
-    ForemanAnsible::UiRolesImporter.any_instance.
-      expects(:import_role_names).returns({})
-
-    ForemanAnsible::VariablesImporter.any_instance.
-      expects(:import_variable_names).returns({
-        :obsolete => [@model]
-      })
-
-    get :import,
-        :params => { :proxy => @proxy.id },
-        :session => set_session_user
-    assert_response :success
-  end
-
   test 'should create ansible variable' do
     params = { :ansible_variable => { :key => 'great name', :ansible_role_id => FactoryBot.create(:ansible_role).id } }
     assert_difference('AnsibleVariable.count', 1) do

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

@@ -45,7 +45,30 @@ module Api
           }, :session => set_session_user
           assert_response :success
         end
+
         test 'should fetch' do
+          @controller = Api::V2::AnsibleRolesController.new
+          @controller.stubs(:prepare_ansible_import_rows).returns(
+            [{
+              :name => 'test_user.test_name',
+              :id => nil,
+              :role_action => 'Import Role',
+              :variables => 'Add: 7',
+              :hosts_count => '',
+              :hostgroup_count => '',
+              :kind => 'new'
+            },
+             {
+               :name => 'some_user.some_role',
+               :id => nil,
+               :role_action => 'Import Role',
+               :variables => 'Add: 3',
+               :hosts_count => '',
+               :hostgroup_count => '',
+               :kind => 'new'
+             }]
+          )
+
           get :fetch, :params => {
             :proxy_id => @proxy.id
           }, :session => set_session_user

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

@@ -9,6 +9,7 @@ module Api
     class HostgroupsControllerTest < ActionController::TestCase
       setup do
         @ansible_role1 = FactoryBot.create(:ansible_role)
+        @ansible_role2 = FactoryBot.create(:ansible_role)
         @host1 = FactoryBot.create(:host, :with_hostgroup)
         @host2 = FactoryBot.create(:host, :with_hostgroup)
         @host3 = FactoryBot.create(:host, :with_hostgroup)
@@ -44,23 +45,23 @@ module Api
       end
 
       test 'should list ansible roles for a host group' do
-        @host3.hostgroup.ansible_roles = [@ansible_role1]
+        FactoryBot.create(:hostgroup_ansible_role, hostgroup_id: @host3.hostgroup.id, ansible_role_id: @ansible_role1.id, position: 0)
         get :ansible_roles, :params => { :id => @host3.hostgroup.id }
         response = JSON.parse(@response.body)
         assert_equal @ansible_role1.id, response.first['id']
       end
 
-      test 'should assign a role to a hostgroup' do
+      test 'should assign a role to a hostgroup with a correct ordering' do
         hostgroup = FactoryBot.create(:hostgroup,
                                       :ansible_role_ids => [])
         post :assign_ansible_roles,
              :params => {
                :id => hostgroup.id,
-               :ansible_role_ids => [@ansible_role1.id]
+               :ansible_role_ids => [@ansible_role2.id, @ansible_role1.id]
              },
              :session => set_session_user
         assert_response :success
-        assert assigns('hostgroup').ansible_roles, [@ansible_role1]
+        assert_equal assigns('hostgroup').ansible_roles, [@ansible_role2, @ansible_role1]
       end
     end
   end

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

@@ -53,9 +53,9 @@ module Api
       end
 
       test 'should update a host with ansible_role_ids param' do
-        host = FactoryBot.create(:host,
-                                 :managed => false,
-                                 :ansible_role_ids => [@ansible_role1.id])
+        host = FactoryBot.create(:host, :managed => false)
+        FactoryBot.create(:host_ansible_role, :host_id => host.id, :ansible_role_id => @ansible_role1.id, :position => 0)
+
         post :update,
              :params => {
                :id => host.id,
@@ -63,28 +63,29 @@ module Api
              },
              :session => set_session_user
         assert_response :success
-        assert assigns('host').ansible_roles, [@ansible_role2]
+        host.reload
+        assert_equal host.ansible_roles, [@ansible_role2]
       end
 
       test 'should list ansible roles for a host' do
-        @host3.ansible_roles = [@ansible_role1]
+        FactoryBot.create(:host_ansible_role, :host_id => @host3.id, :ansible_role_id => @ansible_role1.id, :position => 0)
         get :ansible_roles, :params => { :id => @host3.id }
         response = JSON.parse(@response.body)
         assert_equal @ansible_role1.id, response.first['id']
       end
 
-      test 'should assign a role to a host' do
+      test 'should assign a role to a host with a correct ordering' do
         host = FactoryBot.create(:host,
                                  :managed => false,
                                  :ansible_role_ids => [])
         post :assign_ansible_roles,
              :params => {
                :id => host.id,
-               :ansible_role_ids => [@ansible_role1.id]
+               :ansible_role_ids => [@ansible_role2.id, @ansible_role1.id]
              },
              :session => set_session_user
         assert_response :success
-        assert assigns('host').ansible_roles, [@ansible_role1]
+        assert_equal assigns('host').ansible_roles, [@ansible_role2, @ansible_role1]
       end
     end
   end

data/test/functional/hosts_controller_test.rb

@@ -16,7 +16,9 @@ class HostsControllerExtensionsTest < ActionController::TestCase
     test 'create a host with ansible roles' do
       host = { :name => 'foo',
                :managed => false,
-               :ansible_role_ids => [@role.id] }
+               :host_ansible_roles_attributes => {
+                 0 => { :ansible_role_id => @role.id, :position => 0 }
+               } }
       post :create, :params => { :host => host }, :session => set_session_user
       assert_redirected_to host_url(assigns('host'))
       assert assigns('host').ansible_roles, [@role]
@@ -27,17 +29,19 @@ class HostsControllerExtensionsTest < ActionController::TestCase
       post :update,
            :params => {
              :id => host.id,
-             :host => { :ansible_role_ids => [@role.id] }
+             :host => { :host_ansible_roles_attributes => {
+               0 => { :ansible_role_id => @role.id, :position => 0 }
+             } }
            },
            :session => set_session_user
       assert_redirected_to host_url(assigns('host'))
-      assert assigns('host').ansible_roles, [@role]
+      assert_equal assigns('host').ansible_roles, [@role]
     end
 
     test 'delete a host with ansible roles' do
-      host = FactoryBot.create(:host,
-                               :managed => false,
-                               :ansible_roles => [@role])
+      host = FactoryBot.create(:host, :managed => false)
+      FactoryBot.create(:host_ansible_role, host_id: host.id, ansible_role_id: @role.id, position: 0)
+
       assert_include @role.hosts, host
       delete :destroy,
              :params => { :id => host.id },

data/test/unit/concerns/host_managed_extensions_test.rb

@@ -9,8 +9,8 @@ class HostManagedExtensionsTest < ActiveSupport::TestCase
     @role2 = FactoryBot.create(:ansible_role)
     @role3 = FactoryBot.create(:ansible_role)
 
-    @hostgroup_parent = FactoryBot.create(:hostgroup,
-                                          :ansible_roles => [@role2])
+    @hostgroup_parent = FactoryBot.create(:hostgroup)
+    FactoryBot.create(:hostgroup_ansible_role, hostgroup_id: @hostgroup_parent.id, ansible_role_id: @role2.id)
     @hostgroup = FactoryBot.create(:hostgroup, :parent => @hostgroup_parent)
     @host = FactoryBot.build_stubbed(:host, :ansible_roles => [@role1])
     @another_host = FactoryBot.build_stubbed(:host, :ansible_roles => [@role3])
@@ -23,7 +23,7 @@ class HostManagedExtensionsTest < ActiveSupport::TestCase
 
     test 'returns assigned and inherited roles for host with a hostgroup' do
       @host.hostgroup = @hostgroup
-      @host.all_ansible_roles.must_equal [@role1, @role2]
+      @host.all_ansible_roles.must_equal [@role2, @role1]
     end
   end
 
@@ -48,4 +48,18 @@ class HostManagedExtensionsTest < ActiveSupport::TestCase
       assert Host::Managed.import_host('192.168.128.27').new_record?
     end
   end
+
+  test 'should correctly order roles for host' do
+    host = FactoryBot.create(:host)
+    FactoryBot.create(:host_ansible_role, :ansible_role_id => @role1.id, :position => 1, :host_id => host.id)
+    FactoryBot.create(:host_ansible_role, :ansible_role_id => @role2.id, :position => 2, :host_id => host.id)
+    FactoryBot.create(:host_ansible_role, :ansible_role_id => @role3.id, :position => 0, :host_id => host.id)
+    host.ansible_roles.must_equal [@role3, @role1, @role2]
+  end
+
+  test 'should order hostgroup roles before host roles' do
+    host = FactoryBot.create(:host, :hostgroup => @hostgroup)
+    FactoryBot.create(:host_ansible_role, :ansible_role_id => @role1.id, :position => 0, :host_id => host.id)
+    host.all_ansible_roles.must_equal [@role2, @role1]
+  end
 end

data/test/unit/concerns/hostgroup_extensions_test.rb

@@ -9,22 +9,23 @@ class HostgroupExtensionsTest < ActiveSupport::TestCase
     @role2 = FactoryBot.create(:ansible_role)
     @role3 = FactoryBot.create(:ansible_role)
 
-    @hostgroup_parent = FactoryBot.create(:hostgroup,
-                                          :ansible_roles => [@role2])
-    @hostgroup = FactoryBot.create(:hostgroup, :ansible_roles => [@role1])
-    @host = FactoryBot.create(:host,
-                              :ansible_roles => [@role3],
-                              :hostgroup => @hostgroup)
+    @hostgroup_parent = FactoryBot.create(:hostgroup)
+    FactoryBot.create(:hostgroup_ansible_role, :hostgroup_id => @hostgroup_parent.id, :ansible_role_id => @role2.id, :position => 1)
+    @hostgroup = FactoryBot.create(:hostgroup)
+    FactoryBot.create(:hostgroup_ansible_role, :hostgroup_id => @hostgroup.id, :ansible_role_id => @role1.id, :position => 10)
+    @host = FactoryBot.create(:host, :hostgroup => @hostgroup)
+    FactoryBot.create(:host_ansible_role, :host_id => @host.id, :ansible_role_id => @role3.id)
   end
 
   describe '#all_ansible_roles' do
     test 'returns assigned roles without any parent hostgroup' do
+      @hostgroup.host_ansible_roles
       @hostgroup.all_ansible_roles.must_equal [@role1, @role3]
     end
 
     test 'returns assigned and inherited roles with from parent hostgroup' do
       @hostgroup.parent = @hostgroup_parent
-      @hostgroup.all_ansible_roles.must_equal [@role1, @role2, @role3]
+      @hostgroup.all_ansible_roles.must_equal [@role2, @role1, @role3]
     end
   end
 
@@ -49,4 +50,9 @@ class HostgroupExtensionsTest < ActiveSupport::TestCase
       @hostgroup.inherited_and_own_ansible_roles.must_equal [@role2, @role1]
     end
   end
+
+  test 'should return ordered roles for hostgroup' do
+    @hostgroup.parent = @hostgroup_parent
+    @hostgroup.inherited_and_own_ansible_roles.must_equal [@role2, @role1]
+  end
 end

data/test/unit/host_ansible_role_test.rb

@@ -12,7 +12,8 @@ class HostAnsibleRoleTest < ActiveSupport::TestCase
   describe 'uniqueness' do
     subject do
       HostAnsibleRole.new(:host => FactoryBot.build(:host),
-                          :ansible_role => FactoryBot.build(:ansible_role))
+                          :ansible_role => FactoryBot.build(:ansible_role),
+                          :position => 0)
     end
     should validate_uniqueness_of(:ansible_role_id).scoped_to(:host_id)
   end

data/test/unit/hostgroup_ansible_role_test.rb

@@ -13,7 +13,8 @@ class HostgroupAnsibleRoleTest < ActiveSupport::TestCase
     subject do
       HostgroupAnsibleRole.new(
         :hostgroup => FactoryBot.build(:hostgroup),
-        :ansible_role => FactoryBot.build(:ansible_role)
+        :ansible_role => FactoryBot.build(:ansible_role),
+        :position => 0
       )
     end
     should validate_uniqueness_of(:ansible_role_id).scoped_to(:hostgroup_id)

data/test/unit/ignore_roles_test.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+# Tests for testing the ignore list
+class IgnoreRolesTest < ActiveSupport::TestCase
+  include ForemanAnsible::AnsibleRolesDataPreparations
+
+  role1 = AnsibleRole.new(:name => 'foo')
+  role2 = AnsibleRole.new(:name => 'bar')
+  role3 = AnsibleRole.new(:name => 'hello.txt')
+  role4 = AnsibleRole.new(:name => 'hello.yml')
+  role5 = AnsibleRole.new(:name => 'foo.yml')
+
+  describe 'It should Ignore Role' do
+    test 'If role starts with h' do
+      Setting.stubs(:[]).with(:ansible_roles_to_ignore).returns(['h*'])
+      assert_not role_match_excluded_roles(role1.name)
+      assert_not role_match_excluded_roles(role2.name)
+      assert role_match_excluded_roles(role3.name)
+      assert role_match_excluded_roles(role4.name)
+      assert_not role_match_excluded_roles(role5.name)
+    end
+
+    test 'If role ends with .yml' do
+      Setting.stubs(:[]).with(:ansible_roles_to_ignore).returns(['*.yml'])
+      assert_not role_match_excluded_roles(role1.name)
+      assert_not role_match_excluded_roles(role2.name)
+      assert_not role_match_excluded_roles(role3.name)
+      assert role_match_excluded_roles(role4.name)
+      assert role_match_excluded_roles(role5.name)
+    end
+
+    test 'If role have o char in the middle' do
+      Setting.stubs(:[]).with(:ansible_roles_to_ignore).returns(['*o*'])
+      assert role_match_excluded_roles(role1.name)
+      assert_not role_match_excluded_roles(role2.name)
+      assert role_match_excluded_roles(role3.name)
+      assert role_match_excluded_roles(role4.name)
+      assert role_match_excluded_roles(role5.name)
+    end
+  end
+end

data/test/unit/import_roles_and_variables.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'test_plugin_helper'
+
+# Tests for testing the ignore list
+class ImportRolesAndVariables < ActiveSupport::TestCase
+  include ForemanAnsible::AnsibleRolesDataPreparations
+
+  # existing Roles -> should be updated
+  role1 = AnsibleRole.new(:name => 'ntp', :id => 10)
+  role2 = AnsibleRole.new(:name => 'bar', :id => 11)
+
+  # New Roles -> Should be imported
+  role3 = AnsibleRole.new(:name => 'foo', :id => nil)
+  role4 = AnsibleRole.new(:name => 'world', :id => nil)
+
+  # Existing Role -> should be removed
+  role5 = AnsibleRole.new(:name => 'h', :id => 12)
+
+  # role1 variables -> add
+  variable1 = AnsibleVariable.new(:key => 'ntp_statistics', :ansible_role_id => 10, :id => nil)
+  variable2 = AnsibleVariable.new(:key => 'ntp_broadcast', :ansible_role_id  => 10, :id => nil)
+
+  # role1 variables -> update
+  variable3 = AnsibleVariable.new(:key => 'ntp_statistics', :ansible_role_id => 10, :id => 4)
+  variable4 = AnsibleVariable.new(:key => 'ntp_crypto', :ansible_role_id => 10, :id => 5)
+
+  # role1 variables -> obsolete
+  variable5 = AnsibleVariable.new(:key => 'ntp_controlkey', :ansible_role_id => 10, :id => 6)
+  variable6 = AnsibleVariable.new(:key => 'ntp_key', :ansible_role_id  => 10, :id => 7)
+
+  # role2 variable -> Update
+  variable7 = AnsibleVariable.new(:key => 'bar_key', :ansible_role_id  => 11, :id => 7, :override => false, :hidden_value => true)
+  changed = { 'old' => [role1, role2], 'new' => [role3, role4], 'obsolete' => [role5] }
+  old_roles_variables = { 'new' => [variable1, variable2], 'update' => [variable3, variable4, variable7], 'obsolete' => [variable5, variable6] }
+
+  describe 'It should prepare the rows correctly' do
+    setup do
+      @variables_importer = mock('mock_variables_importer')
+    end
+
+    test 'prepare 5 rows' do
+      expected = [{ :cells => [role1.name, 'Update Role Variables', 'Add: 2, Remove: 2, Update: 2', '', ''],
+                    :role => role1, :kind => 'old', :id => role1.name },
+                  { :cells => [role2.name, 'Update Role Variables', 'Update: 1', '', ''], :role => role2, :kind => 'old', :id => role2.name },
+                  { :cells => [role3.name, 'Import Role', 'Add: 3', '', ''], :role => role3, :kind => 'new', :id => role3.name },
+                  { :cells => [role4.name, 'Import Role', 'Add: 2', '', ''], :role => role4, :kind => 'new', :id => role4.name },
+                  { :cells => [role5.name, 'Remove Role', '', 0, 0], :role => role5, :kind => 'obsolete', :id => role5.name }]
+      # role3 and role4 importing new variables
+      @variables_importer.expects(:get_variables_names).with(role3.name).returns({ 'a' => true, 'b' => false, 'c' => [] })
+      @variables_importer.expects(:get_variables_names).with(role4.name).returns({ 'd' => true, 'e' => false })
+
+      @variables_importer.expects(:import_variable_names).with([role3, role4]).returns(old_roles_variables)
+      @variables_importer.expects(:import_variable_names).with([role1, role2]).returns(old_roles_variables)
+      @variables_importer.expects(:import_variable_names).with([role5]).returns(old_roles_variables)
+      result = prepare_ansible_import_rows(changed, @variables_importer)
+      assert_equal result, expected
+    end
+  end
+end