foreman_discovery 3.0.0 → 4.0.0

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

@@ -65,7 +65,9 @@ class Api::V2::DiscoveredHostsControllerTest < ActionController::TestCase
   def test_auto_provision_success_via_upload
     disable_orchestration
     facts = @facts.merge({"somefact" => "abc"})
-    FactoryGirl.create(:discovery_rule, :priority => 1, :name => 'rule', :search => "facts.somefact = abc", :hostgroup => hostgroups(:common))
+    FactoryGirl.create(:discovery_rule, :priority => 1, :name => 'rule', :search => "facts.somefact = abc",
+                       :hostgroup => FactoryGirl.create(:hostgroup, :with_os, :with_rootpass), :organizations => [Organization.first],
+                       :locations => [Location.first])
     post :facts, { :facts => facts }
     assert_response :success
     assert_equal "Auto-discovered and provisioned via rule 'rule'", Host.first.comment
@@ -75,8 +77,35 @@ class Api::V2::DiscoveredHostsControllerTest < ActionController::TestCase
     disable_orchestration
     facts = @facts.merge({"somefact" => "abc"})
     host = Host::Discovered.import_host_and_facts(facts).first
-    FactoryGirl.create(:discovery_rule, :priority => 1, :search => "facts.somefact = abc", :hostgroup => hostgroups(:common))
+    FactoryGirl.create(:discovery_rule, :priority => 1, :search => "facts.somefact = abc",
+                       :hostgroup => FactoryGirl.create(:hostgroup, :with_os, :with_rootpass),
+                       :organizations => [host.organization], :locations => [host.location])
     post :auto_provision, { :id => host.id }
+    assert_match host.name, @response.body
+    assert_response :success
+  end
+
+  def test_auto_provision_with_wrong_org_or_loc_fail
+    disable_orchestration
+    facts = @facts.merge({"somefact" => "abc"})
+    host = Host::Discovered.import_host_and_facts(facts).first
+    FactoryGirl.create(:discovery_rule, :priority => 1, :search => "facts.somefact = abc",
+                       :hostgroup => FactoryGirl.create(:hostgroup, :with_os, :with_rootpass))
+    post :auto_provision, { :id => host.id }
+    show_response = ActiveSupport::JSON.decode(@response.body)
+    assert_equal "No rule found for host #{host.name}", show_response["error"]["message"]
+  end
+
+  def test_auto_provision_with_wrong_disabled_org_sucess
+    disable_orchestration
+    SETTINGS[:organizations_enabled] = false
+    facts = @facts.merge({"somefact" => "abc"})
+    host = Host::Discovered.import_host_and_facts(facts).first
+    FactoryGirl.create(:discovery_rule, :priority => 1, :search => "facts.somefact = abc",
+                       :hostgroup => FactoryGirl.create(:hostgroup, :with_os, :with_rootpass),
+                       :locations => [host.location])
+    post :auto_provision, { :id => host.id }
+    assert_match host.name, @response.body
     assert_response :success
   end
 
@@ -84,30 +113,38 @@ class Api::V2::DiscoveredHostsControllerTest < ActionController::TestCase
     disable_orchestration
     facts = @facts.merge({"somefact" => "abc"})
     host = Host::Discovered.import_host_and_facts(facts).first
-    FactoryGirl.create(:discovery_rule, :priority => 1, :search => "facts.somefact = abc", :hostgroup => hostgroups(:common))
+    FactoryGirl.create(:discovery_rule, :priority => 1, :search => "facts.somefact = abc",
+                       :hostgroup => FactoryGirl.create(:hostgroup, :with_os, :with_rootpass),
+                       :organizations => [host.organization], :locations => [host.location])
     post :auto_provision, { :id => host.id }
     assert_response :success
     # test deletion of a managed host
     switch_controller(::Api::V2::HostsController) do
       delete :destroy, { :id => host.id }
+      assert_match host.name, @response.body
       assert_response :success
     end
   end
 
-  def test_auto_provision_no_rule_success
+  def test_auto_provision_no_rule_error
     disable_orchestration
     facts = @facts.merge({"somefact" => "abc"})
     host = Host::Discovered.import_host_and_facts(facts).first
     post :auto_provision, { :id => host.id }
-    assert_response :success
+    assert_response :not_found
+    show_response = ActiveSupport::JSON.decode(@response.body)
+    assert_equal "No rule found for host #{host.name}", show_response["error"]["message"]
   end
 
   def test_auto_provision_all_success
     disable_orchestration
     facts = @facts.merge({"somefact" => "abc"})
-    Host::Discovered.import_host_and_facts(facts).first
-    FactoryGirl.create(:discovery_rule, :priority => 1, :search => "facts.somefact = abc", :hostgroup => hostgroups(:common))
+    host = Host::Discovered.import_host_and_facts(facts).first
+    FactoryGirl.create(:discovery_rule, :priority => 1, :search => "facts.somefact = abc",
+                       :hostgroup => FactoryGirl.create(:hostgroup, :with_os, :with_rootpass), :organizations => [host.organization],
+                       :locations => [host.location])
     post :auto_provision_all, {}
+    assert_equal '{}', @response.body
     assert_response :success
   end
 
@@ -116,6 +153,7 @@ class Api::V2::DiscoveredHostsControllerTest < ActionController::TestCase
     facts = @facts.merge({"somefact" => "abc"})
     Host::Discovered.import_host_and_facts(facts).first
     post :auto_provision_all, {}
+    assert_equal '{}', @response.body
     assert_response :success
   end
 

data/test/functional/discovered_hosts_controller_test.rb

@@ -6,12 +6,17 @@ class DiscoveredHostsControllerTest < ActionController::TestCase
   setup do
     @request.env['HTTP_REFERER'] = '/discovery_rules'
     @facts = {
-      "interfaces"       => "lo,eth0",
-      "ipaddress"        => "192.168.100.42",
-      "ipaddress_eth0"   => "192.168.100.42",
-      "macaddress_eth0"  => "AA:BB:CC:DD:EE:FF",
-      "discovery_bootif" => "AA:BB:CC:DD:EE:FF",
+      "interfaces"             => "lo,eth0",
+      "ipaddress"              => "192.168.100.42",
+      "ipaddress_eth0"         => "192.168.100.42",
+      "macaddress_eth0"        => "AA:BB:CC:DD:EE:FF",
+      "discovery_bootif"       => "AA:BB:CC:DD:EE:FF",
+      "physicalprocessorcount" => "42",
     }
+    FactoryGirl.create(:setting,
+                       :name => 'discovery_reboot',
+                       :value => true,
+                       :category => 'Setting::Discovered')
   end
 
   def test_index
@@ -31,7 +36,7 @@ class DiscoveredHostsControllerTest < ActionController::TestCase
     assert_response :success
   end
 
-  def test_edit_form
+  def test_edit_form_elements
     host = Host::Discovered.import_host_and_facts(@facts).first
     get :edit, {:id => host.id}, set_session_user
     assert_select "select" do |elements|
@@ -42,9 +47,12 @@ class DiscoveredHostsControllerTest < ActionController::TestCase
     end
   end
 
-  def test_index_json
-    get :index, {:format => "json"}, set_session_user
-    assert_response :success
+  def test_edit_form_attributes
+    host = Host::Discovered.import_host_and_facts(@facts).first
+    Host.transaction do
+      get :edit, {:id => host.id}, set_session_user
+    end
+    assert_not_nil host.cpu_count
   end
 
   def test_add_entry_to_nav_menu
@@ -80,10 +88,10 @@ class DiscoveredHostsControllerTest < ActionController::TestCase
     host = FactoryGirl.create(:host,
                               :ip   => '1.2.3.4',
                               :type => "Host::Discovered")
-    ::ProxyAPI::BMC.any_instance.expects(:power).raises("request must fail")
+    ::ProxyAPI::BMC.any_instance.expects(:power).raises("request failed")
     post "reboot", { :id => host.id }, set_session_user
     assert_redirected_to discovered_hosts_url
-    assert_equal "Failed to reboot host #{host.name} with error request must fail", flash[:error]
+    assert_match(/ERF50-6734/, flash[:error])
   end
 
   def test_auto_provision_success
@@ -125,6 +133,39 @@ class DiscoveredHostsControllerTest < ActionController::TestCase
     assert_nil flash[:error]
   end
 
+  def test_reboot_all_success
+    @request.env["HTTP_REFERER"] = discovered_hosts_url
+    host = FactoryGirl.create(:host,
+                              :ip   => '1.2.3.4',
+                              :type => "Host::Discovered")
+    ::ProxyAPI::BMC.any_instance.stubs(:power).returns(true)
+    post "reboot", { :id => host.id }, set_session_user
+    assert_redirected_to discovered_hosts_url
+    assert_equal "Rebooting host #{host.name}", flash[:notice]
+  end
+
+  def test_reboot_all_failure
+    @request.env["HTTP_REFERER"] = discovered_hosts_url
+    host = FactoryGirl.create(:host,
+                              :ip   => '1.2.3.4',
+                              :type => "Host::Discovered")
+    ::ProxyAPI::BMC.any_instance.stubs(:power).returns(false)
+    post "reboot_all", { }, set_session_user
+    assert_redirected_to discovered_hosts_url
+    assert_equal "Errors during reboot: #{host.name}: failed to reboot", flash[:error]
+  end
+
+  def test_reboot_all_error
+    @request.env["HTTP_REFERER"] = discovered_hosts_url
+    FactoryGirl.create(:host,
+                       :ip   => '1.2.3.4',
+                       :type => "Host::Discovered")
+    ::ProxyAPI::BMC.any_instance.expects(:power).raises("request must fail")
+    post "reboot_all", { }, set_session_user
+    assert_redirected_to discovered_hosts_url
+    assert_match(/ERF50-6734/, flash[:error])
+  end
+
   private
 
   def initialize_host

data/test/unit/discovered_extensions_test.rb

@@ -41,31 +41,38 @@ class FindDiscoveryRulesTest < ActiveSupport::TestCase
   test "rule out of one is found for a discovered host" do
     facts = @facts.merge({"somefact" => "abc"})
     host = Host::Discovered.import_host_and_facts(facts).first
-    r1 = FactoryGirl.create(:discovery_rule, :priority => 1, :search => "facts.somefact = abc")
+    r1 = FactoryGirl.create(:discovery_rule, :priority => 1, :search => "facts.somefact = abc",
+                            :organizations => [host.organization], :locations => [host.location])
     assert_equal find_discovery_rule(host), r1
   end
 
   test "first rule out of two is found for a discovered host" do
     facts = @facts.merge({"somefact" => "abc"})
     host = Host::Discovered.import_host_and_facts(facts).first
-    r1 = FactoryGirl.create(:discovery_rule, :priority => 1, :search => "facts.somefact = abc")
-    FactoryGirl.create(:discovery_rule, :priority => 2, :search => "facts.somefact = abc")
+    r1 = FactoryGirl.create(:discovery_rule, :priority => 1, :search => "facts.somefact = abc",
+                            :organizations => [host.organization], :locations => [host.location])
+    FactoryGirl.create(:discovery_rule, :priority => 2, :search => "facts.somefact = abc",
+                       :organizations => [host.organization], :locations => [host.location])
     assert_equal find_discovery_rule(host), r1
   end
 
   test "second rule out of two is found for a discovered host" do
     facts = @facts.merge({"somefact" => "abc"})
     host = Host::Discovered.import_host_and_facts(facts).first
-    FactoryGirl.create(:discovery_rule, :priority => 1, :search => "facts.somefact = x")
-    r2 = FactoryGirl.create(:discovery_rule, :priority => 2, :search => "facts.somefact = abc")
+    FactoryGirl.create(:discovery_rule, :priority => 1, :search => "facts.somefact = x",
+                       :organizations => [host.organization], :locations => [host.location])
+    r2 = FactoryGirl.create(:discovery_rule, :priority => 2, :search => "facts.somefact = abc",
+                            :organizations => [host.organization], :locations => [host.location])
     assert_equal find_discovery_rule(host), r2
   end
 
   test "drained rule does not match for a discovered host" do
     facts = @facts.merge({"somefact" => "abc"})
     host = Host::Discovered.import_host_and_facts(facts).first
-    r1 = FactoryGirl.create(:discovery_rule, :priority => 1, :search => "facts.somefact = abc", :max_count => 1)
-    r2 = FactoryGirl.create(:discovery_rule, :priority => 2, :search => "facts.somefact = abc")
+    r1 = FactoryGirl.create(:discovery_rule, :priority => 1, :search => "facts.somefact = abc", :max_count => 1,
+                            :organizations => [host.organization], :locations => [host.location])
+    r2 = FactoryGirl.create(:discovery_rule, :priority => 2, :search => "facts.somefact = abc",
+                            :organizations => [host.organization], :locations => [host.location])
     FactoryGirl.create(:host, :discovery_rule => r1)
     assert_equal find_discovery_rule(host), r2
   end
@@ -73,7 +80,8 @@ class FindDiscoveryRulesTest < ActiveSupport::TestCase
   test "discovery rule is associated after auto provisioning" do
     facts = @facts.merge({"somefact" => "abc"})
     host = Host::Discovered.import_host_and_facts(facts).first
-    r1 = FactoryGirl.create(:discovery_rule, :priority => 1, :search => "facts.somefact = abc")
+    r1 = FactoryGirl.create(:discovery_rule, :priority => 1, :search => "facts.somefact = abc",
+                            :organizations => [host.organization], :locations => [host.location])
     perform_auto_provision host, r1
     assert_equal host.primary_interface.managed, true
     assert_equal host.build, true
@@ -84,15 +92,18 @@ class FindDiscoveryRulesTest < ActiveSupport::TestCase
   test "rules with incorrect syntax are skipped" do
     facts = @facts.merge({"somefact" => "abc"})
     host = Host::Discovered.import_host_and_facts(facts).first
-    FactoryGirl.create(:discovery_rule, :priority => 1, :search => '=!^$#@?x')
-    r2 = FactoryGirl.create(:discovery_rule, :priority => 2, :search => "facts.somefact = abc")
+    FactoryGirl.create(:discovery_rule, :priority => 1, :search => '=!^$#@?x',
+                       :organizations => [host.organization], :locations => [host.location])
+    r2 = FactoryGirl.create(:discovery_rule, :priority => 2, :search => "facts.somefact = abc",
+                            :organizations => [host.organization], :locations => [host.location])
     assert_equal find_discovery_rule(host), r2
   end
 
   test "hostname is copied after auto provisioning" do
     facts = @facts.merge({"somefact" => "abc"})
     host = Host::Discovered.import_host_and_facts(facts).first
-    r1 = FactoryGirl.create(:discovery_rule, :priority => 1, :search => "facts.somefact = abc")
+    r1 = FactoryGirl.create(:discovery_rule, :priority => 1, :search => "facts.somefact = abc",
+                            :organizations => [host.organization], :locations => [host.location])
     perform_auto_provision host, r1
     assert_equal host.name, "macaabbccddeeff"
   end
@@ -121,7 +132,9 @@ class FindDiscoveryRulesTest < ActiveSupport::TestCase
       host = Host::Discovered.import_host_and_facts(@facts).first
       r1 = FactoryGirl.create(:discovery_rule,
                               :search => "facts.somefact = abc",
-                              :hostname => '<%= "" %>')
+                              :hostname => '<%= "" %>',
+                              :organizations => [host.organization],
+                              :locations => [host.location])
       perform_auto_provision host, r1
       assert_equal "macaabbccddeeff", host.name
     end
@@ -130,7 +143,9 @@ class FindDiscoveryRulesTest < ActiveSupport::TestCase
       host = Host::Discovered.import_host_and_facts(@facts).first
       r1 = FactoryGirl.create(:discovery_rule,
                               :search => "facts.somefact = abc",
-                              :hostname => 'x<%= 1+1 %>')
+                              :hostname => 'x<%= 1+1 %>',
+                              :organizations => [host.organization],
+                              :locations => [host.location])
       perform_auto_provision host, r1
       assert_equal "x2", host.name
     end
@@ -139,7 +154,9 @@ class FindDiscoveryRulesTest < ActiveSupport::TestCase
       host = Host::Discovered.import_host_and_facts(@facts).first
       r1 = FactoryGirl.create(:discovery_rule,
                               :search => "facts.somefact = abc",
-                              :hostname => 'x<%= rand(4) %>')
+                              :hostname => 'x<%= rand(4) %>',
+                              :organizations => [host.organization],
+                              :locations => [host.location])
       perform_auto_provision host, r1
       assert_match(/x[0123]/, host.name)
     end
@@ -148,7 +165,9 @@ class FindDiscoveryRulesTest < ActiveSupport::TestCase
       host = Host::Discovered.import_host_and_facts(@facts).first
       r1 = FactoryGirl.create(:discovery_rule,
                               :search => "facts.somefact = abc",
-                              :hostname => 'x<%= @host.name %>')
+                              :hostname => 'x<%= @host.name %>',
+                              :organizations => [host.organization],
+                              :locations => [host.location])
       perform_auto_provision host, r1
       assert_equal "xmacaabbccddeeff", host.name
     end
@@ -157,7 +176,9 @@ class FindDiscoveryRulesTest < ActiveSupport::TestCase
       host = Host::Discovered.import_host_and_facts(@facts).first
       r1 = FactoryGirl.create(:discovery_rule,
                               :search => "facts.somefact = abc",
-                              :hostname => 'x<%= @host.ip.gsub(".","-") %>')
+                              :hostname => 'x<%= @host.ip.gsub(".","-") %>',
+                              :organizations => [host.organization],
+                              :locations => [host.location])
       perform_auto_provision host, r1
       assert_equal "x192-168-100-42", host.name
     end
@@ -167,7 +188,9 @@ class FindDiscoveryRulesTest < ActiveSupport::TestCase
       host = Host::Discovered.import_host_and_facts(@facts).first
       r1 = FactoryGirl.create(:discovery_rule,
                               :search => "facts.somefact = abc",
-                              :hostname => 'x<%= @host.facts["somefact"] %>')
+                              :hostname => 'x<%= @host.facts["somefact"] %>',
+                              :organizations => [host.organization],
+                              :locations => [host.location])
       perform_auto_provision host, r1
       assert_equal "xabc", host.name
     end

data/test/unit/discovery_rule_test.rb

@@ -0,0 +1,59 @@
+require 'test_helper'
+
+class DiscoveryRuleTest < ActiveSupport::TestCase
+  setup do
+    @hg_org = FactoryGirl.create(:organization, :name => 'hgorg')
+    @hg_org.save!
+    @hostgroup = FactoryGirl.create(:hostgroup)
+    @hostgroup.organizations << @hg_org
+    @hostgroup.save!
+  end
+
+  test "should be able to create a rule without entering hosts limit" do
+    rule = DiscoveryRule.new :name => "myrule",
+      :search => "cpu_count > 1",
+      :priority => "1",
+      :hostgroup_id => @hostgroup.id,
+      :organization_ids => [@hg_org.id]
+    assert_valid rule
+  end
+
+  test "should be able to create a rule without entering priority" do
+    rule = DiscoveryRule.new :name => "myrule",
+      :search => "cpu_count > 1",
+      :max_count => "1",
+      :hostgroup_id => @hostgroup.id,
+      :organization_ids => [@hg_org.id]
+    assert_valid rule
+  end
+
+  test "should not be able to create a rule without a hostgroup" do
+    rule = DiscoveryRule.new :name => "myrule",
+      :search => "cpu_count > 1",
+      :organization_ids => [@hg_org.id]
+    refute_valid rule
+    assert_equal "can't be blank", rule.errors[:hostgroup_id].first
+  end
+
+  test "should enforce hostgroup organizations" do
+    skip unless SETTINGS[:organizations_enabled]
+    rule = DiscoveryRule.new :name => "myrule",
+      :search => "cpu_count > 1",
+      :hostgroup_id => @hostgroup.id
+    refute_valid rule
+    assert_equal "Host group organization #{@hg_org.name} must also be associated to the discovery rule", rule.errors[:organizations].first
+  end
+
+  test "should enforce hostgroup organizations and locations" do
+    skip unless (SETTINGS[:organizations_enabled] && SETTINGS[:locations_enabled])
+    loc = FactoryGirl.create(:location, :name => "hgloc")
+    @hostgroup.locations << loc
+    @hostgroup.save!
+    rule = DiscoveryRule.new :name => "myrule",
+      :search => "cpu_count > 1",
+      :hostgroup_id => @hostgroup.id,
+      :organization_ids => [@hg_org.id]
+    refute_valid rule
+    assert_equal "Host group location #{loc.name} must also be associated to the discovery rule", rule.errors[:locations].first
+  end
+end

data/test/unit/host_discovered_test.rb

@@ -2,7 +2,6 @@ require 'test_helper'
 
 class HostDiscoveredTest < ActiveSupport::TestCase
   setup do
-    User.current = User.find_by_login "admin"
     FactoryGirl.create(:setting,
                        :name => 'discovery_fact',
                        :value => 'discovery_bootif',
@@ -24,12 +23,39 @@ class HostDiscoveredTest < ActiveSupport::TestCase
     assert Host::Discovered.find_by_name('mace41f13cc3658')
   end
 
+  test "should setup subnet" do
+    raw = parse_json_fixture('/facts.json')
+    subnet = FactoryGirl.create(:subnet, :organizations => [Organization.first], :locations => [Location.first])
+    Subnet.expects(:subnet_for).with('10.35.27.3').returns(subnet)
+    host = Host::Discovered.import_host_and_facts(raw['facts']).first
+    assert_equal subnet, host.primary_interface.subnet
+  end
+
+  test "should setup subnet with org and loc" do
+    org = FactoryGirl.create(:organization, :name => "subnet_org")
+    loc = FactoryGirl.create(:location, :name => "subnet_loc")
+    FactoryGirl.create(:setting,
+                       :name => 'discovery_organization',
+                       :value => org.name,
+                       :category => 'Setting::Discovered')
+    FactoryGirl.create(:setting,
+                       :name => 'discovery_location',
+                       :value => loc.name,
+                       :category => 'Setting::Discovered')
+    raw = parse_json_fixture('/facts.json')
+    subnet = FactoryGirl.create(:subnet, :organizations => [org], :locations => [loc])
+    Subnet.expects(:subnet_for).with('10.35.27.3').returns(subnet)
+    host = Host::Discovered.import_host_and_facts(raw['facts']).first
+    assert_equal subnet, host.primary_interface.subnet
+  end
+
   test "should raise when fact_name setting isn't present" do
     raw = parse_json_fixture('/facts.json')
     Setting[:discovery_fact] = 'macaddress_foo'
-    assert_raises Foreman::Exception do
+    exception = assert_raises(::Foreman::Exception) do
       Host::Discovered.import_host_and_facts(raw['facts'])
     end
+    assert_match(/Expected discovery_fact '\w+' is missing/, exception.message)
   end
 
   test "should be able to refresh facts" do
@@ -51,9 +77,10 @@ class HostDiscoveredTest < ActiveSupport::TestCase
   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'
-    host = Host::Discovered.import_host_and_facts(raw['facts']).first
-    assert_equal 'mace41f13cc3658', host.name
-    assert_equal 'e4:1f:13:cc:36:58', host.mac
+    exception = assert_raises(::Foreman::Exception) do
+      Host::Discovered.import_host_and_facts(raw['facts'])
+    end
+    assert_match(/Unable to detect primary interface using MAC/, exception.message)
   end
 
   test "should create discovered host with prefix" do
@@ -84,8 +111,44 @@ class HostDiscoveredTest < ActiveSupport::TestCase
     assert host.name.start_with?('mac')
   end
 
+  test 'discovered host can be searched in multiple taxonomies' do
+    org1 = FactoryGirl.create(:organization)
+    org2 = FactoryGirl.create(:organization)
+    org3 = FactoryGirl.create(:organization)
+    user = FactoryGirl.create(:user, :organizations => [org1, org2])
+    host1 = FactoryGirl.create(:host, :type => "Host::Discovered", :organization => org1)
+    host2 = FactoryGirl.create(:host, :type => "Host::Discovered", :organization => org2)
+    host3 = FactoryGirl.create(:host, :type => "Host::Discovered", :organization => org3)
+    hosts = nil
+
+    assert_nil Organization.current
+    as_user(user) do
+      hosts = Host::Discovered.all
+    end
+    assert_includes hosts, host1
+    assert_includes hosts, host2
+    refute_includes hosts, host3
+
+    as_user(:one) do
+      hosts = Host::Discovered.all
+    end
+    assert_includes hosts, host1
+    assert_includes hosts, host2
+    assert_includes hosts, host3
+  end
+
+  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 = Host::Discovered.import_host_and_facts(raw['facts']).first
+    host.save
+    h = ::ForemanDiscovery::HostConverter.to_managed(host)
+    refute_valid h
+    assert Token.where(:host_id => h.id).empty?
+  end
+
   def parse_json_fixture(relative_path)
     return JSON.parse(File.read(File.expand_path(File.dirname(__FILE__) + relative_path)))
   end
-
 end

data/test/unit/puppet_fact_parser_extensions_test.rb

@@ -1,63 +1,78 @@
 require 'test_helper'
 
-class DummyPuppetFactParser
-  def ip
-    '192.168.0.30'
-  end
-
-  def primary_interface
-    'eth1'
-  end
+class PuppetFactParserStub
+  attr_reader :interfaces, :facts
 
-  def interfaces
-    {
-      'eth0' => {'macaddress' => 'aa:00:00:00:00:01', 'ipaddress' => '192.168.0.2'},
-      'eth3' => {'ipaddress' => '192.168.2.2'},
-      'eth2' => {'macaddress' => 'bb:00:00:00:00:01', 'ipaddress' => '192.168.1.2'}
-    }.with_indifferent_access
+  def initialize(interfaces, facts)
+    @interfaces = interfaces
+    @facts = facts
   end
 
-  def facts
-    {
-      :ipaddress => '192.168.0.2', :macaddress => 'bb:00:00:00:00:01', :interfaces => 'eth0,eth1,lo',
-      :macaddress_eth1 => 'bb:00:00:00:00:01', :ipaddress_eth1 => '192.168.1.2',
-      :macaddress_eth0 => 'aa:00:00:00:00:01', :ipaddress_eth0 => '192.168.0.2',
-      :macaddress_lo => '', :ipaddress_lo => '127.0.0.1',
-      :mac_fact => 'AA:00:00:00:00:01'
-    }.with_indifferent_access
-  end
+  def suggested_primary_interface(_); end
+  def parse_interfaces?; end
 
   include PuppetFactParserExtensions
 end
 
 class PuppetFactParserTest < ActiveSupport::TestCase
   setup do
-    @parser = DummyPuppetFactParser.new
+    interfaces = {
+      'eth0' => {'macaddress' => 'aa:bb:cc:dd:ee:f1', 'ipaddress' => '192.168.1.1'},
+      'eth1' => {'macaddress' => 'aa:bb:cc:dd:ee:f2', 'ipaddress' => '192.168.1.2'},
+      'eth2' => {'macaddress' => 'aa:bb:cc:dd:ee:f3', 'ipaddress' => '192.168.1.3'},
+    }.with_indifferent_access
+    facts = {
+      :macaddress_eth0 => 'aa:bb:cc:dd:ee:f1',
+      :macaddress_eth1 => 'aa:bb:cc:dd:ee:f2',
+      :macaddress_eth2 => 'aa:bb:cc:dd:ee:f3',
+      :ipaddress_eth0 => '192.168.1.1',
+      :ipaddress_eth1 => '192.168.1.2',
+      :ipaddress_eth2 => '192.168.1.3',
+      :ipaddress => '192.168.1.2',
+      :macaddress => 'aa:bb:cc:dd:ee:f2',
+      :discovery_bootif => 'aa:bb:cc:dd:ee:f3'
+    }.with_indifferent_access
+    @parser = PuppetFactParserStub.new(interfaces, facts)
+    @host = Host::Discovered.new(:name => 'dummy')
   end
 
-  test '#ip_with_discovery_fact ignores discovery part completely if discovery facts are not present' do
-    @parser.stubs(:discovery_mac_fact_name).returns('fact_that_does_not_exist')
-    assert_equal '192.168.0.30', @parser.ip
+  test "#suggested_primary_interface detects interface eth2" do
+    assert_equal 'eth2', @parser.suggested_primary_interface(@host).try(:first)
   end
 
-  test '#ip_with_discovery_fact finds primary interface based on discovery facts and returns it\'s ip' do
-    @parser.stubs(:discovery_mac_fact_name).returns('mac_fact')
-    assert_equal '192.168.0.2', @parser.ip
+  test "#suggested_primary_interface detects interface eth1" do
+    FacterUtils.stubs(:bootif_mac).returns('aa:bb:cc:dd:ee:f2')
+    assert_equal 'eth1', @parser.suggested_primary_interface(@host).try(:first)
   end
 
-  test '#primary_interface_with_discovery_fact finds primary interface based on discovery facts' do
-    @parser.stubs(:discovery_mac_fact_name).returns('mac_fact')
-    assert_equal 'eth0', @parser.primary_interface
+  test "#suggested_primary_interface detects interface with user defined bootif fact name" do
+    FacterUtils.stubs(:bootif_name).returns('my_primary')
+    @parser.facts[:my_primary] = 'aa:bb:cc:dd:ee:f1'
+    assert_equal 'eth0', @parser.suggested_primary_interface(@host).try(:first)
   end
 
-  test '#primary_interface_with_discovery_fact falls back if no interface can be found by discovery mac' do
-    @parser.facts[:mac_fact] = 'cc:00:00:00:00:01'
-    @parser.stubs(:discovery_mac_fact_name).returns('mac_fact')
-    assert_equal 'eth0', @parser.primary_interface
+  test "#suggested_primary_interface errors out when bootif fact defines unknown MAC" do
+    @parser.facts[:discovery_bootif] = 'aa:aa:aa:aa:aa:aa'
+    exception = assert_raises(::Foreman::Exception) do
+      @parser.suggested_primary_interface(@host)
+    end
+    assert_match(/Unable to detect primary interface using MAC/, exception.message)
   end
 
-  test '#primary_interface_with_discovery_fact uses macaddress fact if discovery facts not available' do
-    @parser.stubs(:discovery_mac_fact_name).returns('fact_that_does_not_exist')
-    assert_equal 'eth1', @parser.primary_interface
+  test "#suggested_primary_interface errors out when bootif fact is missing" do
+    @parser.facts.delete(:discovery_bootif)
+    exception = assert_raises(::Foreman::Exception) do
+      @parser.suggested_primary_interface(@host)
+    end
+    assert_match(/Unable to detect primary interface using MAC/, exception.message)
   end
+
+  test "#suggested_primary_interface detects interface even when 'ignore_puppet_facts_for_provisioning' is set" do
+    FactoryGirl.create(:setting,
+                       :name => 'ignore_puppet_facts_for_provisioning',
+                       :value => true,
+                       :category => 'Setting::Provisioning')
+    assert_equal 'eth2', @parser.suggested_primary_interface(@host).try(:first)
+  end
+
 end