foreman_discovery 11.0.0 → 12.0.0

data/test/models/setting_test.rb

@@ -0,0 +1,11 @@
+require 'test_helper'
+
+class SettingTest < ActiveSupport::TestCase
+  test "should update hostname prefix with multiple valid values" do
+    setting = FactoryBot.create(:setting, :name => 'discovery_prefix', :value => 'mac', :category => 'Setting::Discovered')
+    RFauxFactory.gen_strings(exclude: [:numeric, :alphanumeric]).values.each do |value|
+      setting.value = value
+      assert setting.valid?, "Can't update discovery_prefix setting with valid value #{value}"
+    end
+  end
+end

data/test/test_helper_discovery.rb

@@ -66,6 +66,7 @@ def set_default_settings
   FactoryBot.create(:setting, :name => 'discovery_pxegrub_lock_template', :value => 'pxegrub_discovery', :category => 'Setting::Discovered')
   FactoryBot.create(:setting, :name => 'discovery_pxegrub2_lock_template', :value => 'pxegrub2_discovery', :category => 'Setting::Discovered')
   FactoryBot.create(:setting, :name => 'discovery_always_rebuild_dns', :value => true, :category => 'Setting::Discovered')
+  FactoryBot.create(:setting, :name => 'discovery_error_on_existing', :value => false, :category => 'Setting::Discovered')
 end
 
 def setup_hostgroup(host)

data/test/unit/discovered_extensions_test.rb

@@ -48,7 +48,7 @@ class DiscoveredExtensionsTest < ActiveSupport::TestCase
     host = discover_host_from_facts(facts)
     r1 = FactoryBot.create(:discovery_rule, :priority => 1, :search => "facts.somefact = abc",
                             :organizations => [host.organization], :locations => [host.location])
-    FactoryBot.create(:discovery_rule, :priority => 1, :search => "facts.somefact = x",
+    FactoryBot.create(:discovery_rule, :priority => 0, :search => "facts.somefact = x",
                        :organizations => [host.organization], :locations => [host.location])
     assert_equal find_discovery_rule(host), r1
   end
@@ -56,7 +56,7 @@ class DiscoveredExtensionsTest < ActiveSupport::TestCase
   test "second rule out of two is found for a discovered host" do
     facts = @facts.merge({"somefact" => "abc"})
     host = discover_host_from_facts(facts)
-    FactoryBot.create(:discovery_rule, :priority => 1, :search => "facts.somefact = x",
+    FactoryBot.create(:discovery_rule, :priority => 0, :search => "facts.somefact = x",
                        :organizations => [host.organization], :locations => [host.location])
     r2 = FactoryBot.create(:discovery_rule, :priority => 1, :search => "facts.somefact = abc",
                             :organizations => [host.organization], :locations => [host.location])
@@ -83,17 +83,6 @@ class DiscoveredExtensionsTest < ActiveSupport::TestCase
     assert_equal find_discovery_rule(host), r2
   end
 
-  test "older rule out of two is found for a discovered host" do
-    facts = @facts.merge({"somefact" => "abc"})
-    host = discover_host_from_facts(facts)
-    r1 = FactoryBot.create(:discovery_rule, :priority => 1, :search => "facts.somefact = abc",
-                       :organizations => [host.organization], :locations => [host.location])
-    r2 = FactoryBot.create(:discovery_rule, :priority => 1, :search => "facts.somefact = abc",
-                            :organizations => [host.organization], :locations => [host.location],
-                            :created_at => Time.now + 1.day)
-    assert_equal find_discovery_rule(host), r1
-  end
-
   test "drained rule does not match for a discovered host" do
     facts = @facts.merge({"somefact" => "abc"})
     host = discover_host_from_facts(facts)

data/test/unit/discovery_rule_test.rb

@@ -5,6 +5,9 @@ class DiscoveryRuleTest < ActiveSupport::TestCase
     @hostgroup = FactoryBot.create(:hostgroup)
   end
 
+  should allow_values(*valid_name_list).for(:name)
+  should_not allow_values(*invalid_name_list).for(:name)
+
   context "#validates attribute" do
     setup do
       @huge_name = "x" * 256
@@ -52,6 +55,12 @@ class DiscoveryRuleTest < ActiveSupport::TestCase
     end
   end
 
+  test_attributes :pid => 'b8ae7a80-b9a8-4924-808c-482a2b4102c4'
+  test "should create discovery rule with name and minimum required attributes" do
+    rule = DiscoveryRule.new(:name => 'new_rule', :search => 'cpu_count = 1', :hostgroup_id => hostgroups(:unusual).id)
+    assert_valid rule
+  end
+
   test "should be able to create a rule without entering hosts limit" do
     rule = DiscoveryRule.new :name => "myrule",
       :search => "cpu_count > 1",
@@ -72,7 +81,7 @@ class DiscoveryRuleTest < ActiveSupport::TestCase
     assert_valid rule
   end
 
-  test "should not be able to create a rule without a hostgroup" do
+  test "should not be able to create a rule without a hostgroup-id" do
     rule = DiscoveryRule.new :name => "myrule",
       :search => "cpu_count > 1",
       :organization_ids => [organization_one.id],
@@ -81,6 +90,30 @@ class DiscoveryRuleTest < ActiveSupport::TestCase
     assert_equal "can't be blank", rule.errors[:hostgroup_id].first
   end
 
+  test "should not be able to create a rule without a valid hostgroup" do
+    rule = DiscoveryRule.new :name => "myrule",
+      :search => "cpu_count > 1",
+      :organization_ids => [organization_one.id],
+      :location_ids => [location_one.id],
+      :hostgroup_id => 99999
+    refute_valid rule
+
+    assert_equal "must be present.", rule.errors[:hostgroup].first
+  end
+
+  test_attributes :pid => '4ec7d76a-22ba-4c3e-952c-667a6f0a5728'
+  test "should not create with invalid priority type" do
+    rule = DiscoveryRule.new(
+      :name => 'new_rule',
+      :search => 'cpu_count = 1',
+      :hostgroup_id => hostgroups(:unusual).id,
+      :priority => 'invalid priority type'
+    )
+    refute_valid rule
+    assert rule.errors.key?(:priority)
+    assert_equal "is not a number", rule.errors[:priority].first
+  end
+
   test "should not be able to create a rule with priority bigger than 2^31" do
     rule = DiscoveryRule.new :name => "myrule",
       :search => "cpu_count > 1",
@@ -92,6 +125,19 @@ class DiscoveryRuleTest < ActiveSupport::TestCase
     assert_equal "must be less than 2147483648", rule.errors[:priority].first
   end
 
+  test_attributes :pid => '84503d8d-86f6-49bf-ab97-eff418d3e3d0'
+  test "should not create with invalid max count type" do
+    rule = DiscoveryRule.new(
+      :name => 'new_rule',
+      :search => 'cpu_count = 1',
+      :hostgroup_id => hostgroups(:unusual).id,
+      :max_count => 'invalid max_count type'
+    )
+    refute_valid rule
+    assert rule.errors.key?(:max_count)
+    assert_equal "is not a number", rule.errors[:max_count].first
+  end
+
   test "should not be able to create a rule with max count bigger than 2^31" do
     rule = DiscoveryRule.new :name => "myrule",
       :search => "cpu_count > 1",
@@ -125,4 +171,44 @@ class DiscoveryRuleTest < ActiveSupport::TestCase
     refute_valid rule
     assert_equal "Host group location #{loc.name} must also be associated to the discovery rule", rule.errors[:locations].first
   end
+
+  context 'auditing related to discovery rule' do
+    test "should be able to create audit on a rule creation" do
+      rule = nil
+      assert_difference 'Audit.count' do
+        rule = FactoryBot.create(:discovery_rule, :with_auditing)
+      end
+      recent_audit = rule.audits.last
+      assert_equal 'create', recent_audit.action
+    end
+
+    test "should create audit when updating a discovery rule" do
+      rule = FactoryBot.create(:discovery_rule, :with_auditing)
+      assert_difference 'rule.audits.count' do
+        rule.enabled = false
+        rule.save!
+      end
+      audit = rule.audits.last
+      assert_equal 'update', audit.action
+    end
+
+    test "should create audit record when destroying a discovery rule" do
+      rule = FactoryBot.create(:discovery_rule, :with_auditing)
+      assert_difference 'Audit.count' do
+        rule.destroy
+      end
+      audit = rule.audits.last
+      assert_equal 'destroy', audit.action
+    end
+
+    test 'should be able to create audit record on changing hostgroup of rule' do
+      rule = FactoryBot.create(:discovery_rule)
+      hostgroup_one = FactoryBot.create(:hostgroup, :name => "test-hg")
+
+      assert_difference 'hostgroup_one.associated_audits.count' do
+        hostgroup_one.discovery_rules << rule
+        hostgroup_one.save!
+      end
+    end
+  end
 end

data/test/unit/fact_parser_test.rb

@@ -43,7 +43,7 @@ class FactParserTest < ActiveSupport::TestCase
     exception = assert_raises(::Foreman::Exception) do
       @parser.suggested_primary_interface(@host)
     end
-    assert_match(/Unable to detect primary interface using MAC/, exception.message)
+    assert_match(/Unable to find primary NIC/, exception.message)
   end
 
   test "#suggested_primary_interface errors out when bootif fact is missing" do
@@ -51,7 +51,7 @@ class FactParserTest < ActiveSupport::TestCase
     exception = assert_raises(::Foreman::Exception) do
       @parser.suggested_primary_interface(@host)
     end
-    assert_match(/Unable to detect primary interface using MAC/, exception.message)
+    assert_match(/Unable to find primary NIC/, exception.message)
   end
 
   test "#suggested_primary_interface detects interface even when 'ignore_puppet_facts_for_provisioning' is set" do

data/test/unit/host_discovered_test.rb

@@ -26,7 +26,6 @@ class HostDiscoveredTest < ActiveSupport::TestCase
   end
 
   test "should setup subnet" do
-    raw = parse_json_fixture('/facts.json')
     subnet = FactoryBot.create(:subnet_ipv4, :name => 'Subnet99', :network => '10.35.27.0', :organizations => [organization_one], :locations => [location_one])
     Subnet.expects(:subnet_for).with('10.35.27.3').returns(subnet)
     host = discover_host_from_facts(@facts)
@@ -38,7 +37,6 @@ class HostDiscoveredTest < ActiveSupport::TestCase
     loc = FactoryBot.create(:location, :name => "subnet_loc")
     Setting['discovery_organization'] = org.name
     Setting['discovery_location'] = loc.name
-    raw = parse_json_fixture('/facts.json')
     subnet = FactoryBot.create(:subnet_ipv4, :name => 'Subnet99', :network => '10.35.27.0', :organizations => [org], :locations => [loc])
     Subnet.expects(:subnet_for).with('10.35.27.3').returns(subnet)
     host = discover_host_from_facts(@facts)
@@ -48,7 +46,6 @@ class HostDiscoveredTest < ActiveSupport::TestCase
   test "should setup subnet with org and loc set via facts" do
     org = FactoryBot.create(:organization, :name => "subnet_org_via_fact")
     loc = FactoryBot.create(:location, :name => "subnet_loc_via_fact")
-    raw = parse_json_fixture('/facts.json')
     @facts['foreman_organization'] = org.name
     @facts['foreman_location'] = loc.name
     subnet = FactoryBot.create(:subnet_ipv4, :name => 'Subnet99', :network => '10.35.27.0', :organizations => [org], :locations => [loc])
@@ -64,7 +61,6 @@ class HostDiscoveredTest < ActiveSupport::TestCase
     loc = FactoryBot.create(:location, :name => "subloc", :parent_id => loc_parent.id)
     Setting['discovery_organization'] = org.name
     Setting['discovery_location'] = loc.name
-    raw = parse_json_fixture('/facts.json')
     subnet = FactoryBot.create(:subnet_ipv4, :name => 'Subnet99', :network => '10.35.27.0', :organizations => [org], :locations => [loc])
     Subnet.expects(:subnet_for).with('10.35.27.3').returns(subnet)
     host = discover_host_from_facts(@facts)
@@ -73,7 +69,6 @@ class HostDiscoveredTest < ActiveSupport::TestCase
   end
 
   test "should raise when fact_name setting isn't present" do
-    raw = parse_json_fixture('/facts.json')
     Setting[:discovery_fact] = 'macaddress_foo'
     exception = assert_raises(::Foreman::Exception) do
       discover_host_from_facts(@facts)
@@ -83,13 +78,11 @@ class HostDiscoveredTest < ActiveSupport::TestCase
 
   test "should be able to refresh facts" do
     host = Host.create :name => "mydiscoveredhost", :ip => "1.2.3.4", :type => "Host::Discovered"
-    raw = parse_json_fixture('/facts.json')
     ::ForemanDiscovery::NodeAPI::Inventory.any_instance.stubs(:facter).returns(@facts)
     assert host.refresh_facts
   end
 
   test "should create discovered host with hostname if a fact was supplied" do
-    raw = parse_json_fixture('/facts.json')
     Setting[:discovery_hostname] = 'somefact'
     facts = @facts.merge({"somefact" => "somename"})
     host = discover_host_from_facts(facts)
@@ -100,7 +93,6 @@ class HostDiscoveredTest < ActiveSupport::TestCase
   test "should lock host into discovery via PXE configuration" do
     Host::Discovered.delete('mace41f13cc3658')
     Setting[:discovery_lock] = "true"
-    raw = parse_json_fixture('/facts.json')
     subnet = FactoryBot.create(:subnet,
                                 :tftp,
                                 :network => '10.35.27.0',
@@ -124,7 +116,6 @@ class HostDiscoveredTest < ActiveSupport::TestCase
   end
 
   test "should create discovered host with fact_name as a name if it is a valid mac" do
-    raw = parse_json_fixture('/facts.json')
     Setting[:discovery_fact] = 'somefact'
     Setting[:discovery_hostname] = 'somefact'
     facts = @facts.merge({"somefact" => "E4:1F:13:CC:36:5A"})
@@ -134,48 +125,62 @@ class HostDiscoveredTest < ActiveSupport::TestCase
   end
 
   test "should create discovered host with default name if fact_name isn't a valid mac" do
-    raw = parse_json_fixture('/facts.json')
     Setting[:discovery_fact] = 'lsbdistcodename'
     exception = assert_raises(::Foreman::Exception) do
       discover_host_from_facts(@facts)
     end
-    assert_match(/Unable to detect primary interface using MAC/, exception.message)
+    assert_match(/Unable to find primary NIC/, exception.message)
   end
 
   test "should not create discovered host when managed host exists" do
-    FactoryBot.create(:host, :mac => 'E4:1F:13:CC:36:58')
-    raw = parse_json_fixture('/facts.json')
-    exception = assert_raises(::Foreman::Exception) do
-      discover_host_from_facts(@facts)
+    begin
+      Setting[:discovery_error_on_existing] = true
+      FactoryBot.create(:host, :mac => 'E4:1F:13:CC:36:58')
+      exception = assert_raises(::Foreman::Exception) do
+        discover_host_from_facts(@facts)
+      end
+      assert_match(/One or more existing managed hosts found/, exception.message)
+    ensure
+      Setting[:discovery_error_on_existing] = false
     end
-    assert_match(/Host already exists as managed/, exception.message)
+  end
+
+  test "should allow existing managed host discovery" do
+    FactoryBot.create(:host, :mac => 'E4:1F:13:CC:36:58')
+    host = discover_host_from_facts(@facts)
+    assert_equal 'mace41f13cc3658', host.name
+    assert_equal 'e4:1f:13:cc:36:58', host.mac
   end
 
   test "should create discovered host with prefix" do
-    raw = parse_json_fixture('/facts.json')
     Setting[:discovery_prefix] = 'test'
     host = discover_host_from_facts(@facts)
     assert_equal 'teste41f13cc3658', host.name
   end
 
   test "should create discovered host without prefix" do
-    raw = parse_json_fixture('/facts.json')
     Setting[:discovery_prefix] = ''
     host = discover_host_from_facts(@facts)
     assert_equal 'e41f13cc3658',host.name
   end
 
-  test "should refresh existing discovered" do
-    raw = parse_json_fixture('/facts.json')
-    interface = mock()
-    interface.stubs(:host).returns(Host.create(:name => "xyz", :type => "Host::Discovered"))
-    ::Nic::Managed.stubs(:where).with(:mac => @facts['discovery_bootif'].downcase, :primary => true).returns([interface])
-    host = discover_host_from_facts(@facts)
-    assert_equal 'xyz', host.name
+  test "should refresh facts and NICs of an existing discovered host" do
+    host1 = discover_host_from_facts(@facts)
+    assert_equal 'mace41f13cc3658', host1.name
+    assert_equal 'IBM System x -[7870K4G]-', host1.facts["productname"]
+    assert_equal 1, Host::Discovered.where(:name => 'mace41f13cc3658').count
+    assert_equal '10.35.27.3', host1.ip
+
+    @facts["ipaddress_eth0"] = "1.2.3.4"
+    @facts["productname"] = "Dishwasher DW400"
+    host2 = discover_host_from_facts(@facts)
+    assert_equal 'mace41f13cc3658', host2.name
+    assert_equal 'Dishwasher DW400', host2.facts["productname"]
+    assert_equal '1.2.3.4', host2.ip
+    assert_equal 1, Host::Discovered.where(:name => 'mace41f13cc3658').count
   end
 
   test "should raise when hostname fact cannot be found" do
-    raw = parse_json_fixture('/facts.json')
     Setting[:discovery_hostname] = 'macaddress_foo'
     exception = assert_raises(::Foreman::Exception) do
       discover_host_from_facts(@facts)
@@ -184,7 +189,6 @@ class HostDiscoveredTest < ActiveSupport::TestCase
   end
 
   test "should raise when hostname cannot be computed due to normlization and no prefix" do
-    raw = parse_json_fixture('/facts.json')
     @facts['invalidhostnamefact'] = '...'
     Setting[:discovery_hostname] = 'invalidhostnamefact'
     Setting[:discovery_prefix] = ''
@@ -223,7 +227,6 @@ class HostDiscoveredTest < ActiveSupport::TestCase
 
   test "provisioning a discovered host without saving it doesn't create a token" do
     Setting[:token_duration] = 30 #enable tokens so that we only test the CR
-    raw = parse_json_fixture('/facts.json')
     Setting[:discovery_prefix] = '123'
     host = discover_host_from_facts(@facts)
     host.save
@@ -325,6 +328,35 @@ class HostDiscoveredTest < ActiveSupport::TestCase
     assert_equal Host::Discovered.return_first_valid_fact(discovery_hostname_fact_array,facts),"testhostname"
   end
 
+  context 'notification recipients' do
+    setup do
+      @admins = User.except_hidden.where(:admin => true).pluck(:id)
+      @org = FactoryBot.create(:organization)
+      @host = FactoryBot.create(:discovered_host)
+    end
+
+    test 'finds admin users' do
+      assert_equal @admins.sort, @host.notification_recipients_ids.sort
+    end
+
+    test 'finds users who can create_host in the host org' do
+      setup_user 'create', 'hosts'
+      User.current.organizations << @org
+      recipients = [User.current.id, @admins].flatten.sort
+      @host.organization = @org
+      assert_equal recipients, @host.notification_recipients_ids.sort
+    end
+
+    test 'finds only admin users if organizations are disabled' do
+      begin
+        SETTINGS[:organizations_enabled] = false
+        assert_equal @admins.sort, @host.notification_recipients_ids.sort
+      ensure
+        SETTINGS[:organizations_enabled] = true
+      end
+    end
+  end
+
   def parse_json_fixture(relative_path)
     return JSON.parse(File.read(File.expand_path(File.dirname(__FILE__) + relative_path)))
   end

data/test/unit/ui_notifications/destroy_host_test.rb

@@ -7,8 +7,9 @@ class DestroyHostNotificationTest < ActiveSupport::TestCase
     assert blueprint
   end
 
-  test 'destorying discovered host should remove notification' do
+  test 'destroying discovered host should remove notification' do
     host = FactoryBot.create(:discovered_host)
+    ForemanDiscovery::UINotifications::NewHost.deliver!(host)
     assert_difference('blueprint.notifications.count', -1) do
       host.destroy
     end
@@ -16,11 +17,13 @@ class DestroyHostNotificationTest < ActiveSupport::TestCase
 
   test 'do not remove notification if other discovered hosts exists' do
     assert_difference('blueprint.notifications.count') do
-      FactoryBot.create(:discovered_host)
+      host = FactoryBot.create(:discovered_host)
+      ForemanDiscovery::UINotifications::NewHost.deliver!(host)
     end
     assert_equal 1, blueprint.notifications.count
     assert_no_difference('blueprint.notifications.count') do
-      FactoryBot.create(:discovered_host)
+      host = FactoryBot.create(:discovered_host)
+      ForemanDiscovery::UINotifications::NewHost.deliver!(host)
     end
     assert_no_difference('blueprint.notifications.count') do
       Host::Discovered.all.last.destroy
@@ -31,6 +34,7 @@ class DestroyHostNotificationTest < ActiveSupport::TestCase
 
   test 'discovered host type change should update notifications' do
     host = FactoryBot.create(:discovered_host)
+    ForemanDiscovery::UINotifications::NewHost.deliver!(host)
     assert_equal 1, blueprint.notifications.count
     new_host = ::ForemanDiscovery::HostConverter.to_managed(host, false, false)
     assert new_host.save!
@@ -39,10 +43,16 @@ class DestroyHostNotificationTest < ActiveSupport::TestCase
 
   test 'type change should not removing notifications for discovered hosts' do
     host1 = FactoryBot.create(:discovered_host)
-    FactoryBot.create(:discovered_host)
+    ForemanDiscovery::UINotifications::NewHost.deliver!(host1)
+    host2 = FactoryBot.create(:discovered_host)
+    ForemanDiscovery::UINotifications::NewHost.deliver!(host2)
     assert_equal 1, blueprint.notifications.count
     new_host = ::ForemanDiscovery::HostConverter.to_managed(host1, false, false)
     assert new_host.save!
     assert_equal 1, blueprint.notifications.count
   end
+
+  def parse_json_fixture(relative_path)
+    return JSON.parse(File.read(File.expand_path(File.dirname(__FILE__) + relative_path)))
+  end
 end