foreman_salt 1.1.1 → 2.0.0

data/db/migrate/20140817210214_create_salt_modules.rb

@@ -1,7 +1,7 @@
 class CreateSaltModules < ActiveRecord::Migration
   def self.up
     create_table :salt_modules do |t|
-      t.string      :name, :default => '', :null => false
+      t.string :name, :default => '', :null => false
       t.timestamps
     end
 

data/db/migrate/20150220122707_fix_incorrect_report_metrics.rb

@@ -0,0 +1,22 @@
+class FixIncorrectReportMetrics < ActiveRecord::Migration
+  def up
+    Report.all.each do |report|
+      next unless report.metrics && report.metrics['time']
+      metrics = report.metrics.dup
+
+      report.metrics['time'].each do |resource, time|
+        metrics['time'][resource] = if time.is_a? String
+                                      Float(time.delete(' ms')) rescue nil
+                                    else
+                                      time
+                                    end
+      end
+
+      report.update_attributes(:metrics => metrics) if metrics != report.metrics
+    end
+  end
+
+  def down
+    # Nothing
+  end
+end

data/lib/foreman_salt/engine.rb

@@ -2,7 +2,6 @@ require 'deface'
 
 module ForemanSalt
   class Engine < ::Rails::Engine
-
     config.autoload_paths += Dir["#{config.root}/app/controllers/concerns"]
     config.autoload_paths += Dir["#{config.root}/app/helpers/concerns"]
     config.autoload_paths += Dir["#{config.root}/app/models/concerns"]
@@ -11,82 +10,145 @@ module ForemanSalt
     config.autoload_paths += Dir["#{config.root}/app/lib"]
 
     if defined? ForemanTasks
-      initializer 'foreman_salt.require_dynflow', :before => 'foreman_tasks.initialize_dynflow' do |app|
+      initializer 'foreman_salt.require_dynflow', :before => 'foreman_tasks.initialize_dynflow' do |_app|
         ForemanTasks.dynflow.require!
       end
     end
 
-    # Add any db migrations
+    initializer 'foreman_salt.load_default_settings', :before => :load_config_initializers do
+      require_dependency File.expand_path('../../../app/models/setting/salt.rb', __FILE__) if (Setting.table_exists? rescue(false))
+    end
+
     initializer 'foreman_salt.load_app_instance_data' do |app|
       app.config.paths['db/migrate'] += ForemanSalt::Engine.paths['db/migrate'].existent
     end
 
-    initializer 'foreman_salt.register_plugin', :after=> :finisher_hook do |app|
+    initializer 'foreman_salt.apipie' do
+      Apipie.configuration.api_controllers_matcher << "#{ForemanSalt::Engine.root}/app/controllers/foreman_salt/api/v2/*.rb"
+      Apipie.configuration.checksum_path += ['/salt/api/']
+    end
+
+    initializer 'foreman_salt.register_plugin', :after => :finisher_hook do |_app|
       Foreman::Plugin.register :foreman_salt do
-        requires_foreman '>= 1.7'
+        requires_foreman '>= 1.8'
 
+        ## Menus
         menu :top_menu, :salt_environments,
-          :url_hash => {:controller => :'foreman_salt/salt_environments', :action => :index },
-          :caption  => 'Environments',
-          :parent   => :configure_menu,
-          :after    => :common_parameters
+             :url_hash => { :controller => :'foreman_salt/salt_environments', :action => :index },
+             :caption  => 'Environments',
+             :parent   => :configure_menu,
+             :after    => :common_parameters
 
         menu :top_menu, :salt_modules,
-          :url_hash => {:controller => :'foreman_salt/salt_modules', :action => :index },
-          :caption  => 'States',
-          :parent   => :configure_menu,
-          :after    => :common_parameters
+             :url_hash => { :controller => :'foreman_salt/salt_modules', :action => :index },
+             :caption  => 'States',
+             :parent   => :configure_menu,
+             :after    => :common_parameters
 
         divider :top_menu, :parent => :configure_menu,
-          :caption => 'Salt',
-          :after   => :common_parameters
-
-        security_block :hosts do |map|
-          permission :saltrun_hosts, {:hosts => [:saltrun]}, :resource_type => 'Host'
-          permission :view_hosts, {:hosts => [:salt_external_node]}, :resource_type => 'Host'
-        end
-
-        security_block :salt_environments do |map|
-          permission :create_salt_environments, {:'foreman_salt/salt_environments' => [:new, :create]}, :resource_type => 'ForemanSalt::SaltEnvironment'
-          permission :view_salt_environments, {:'foreman_salt/salt_environments' => [:index, :show, :auto_complete_search]}, :resource_type => 'ForemanSalt::SaltEnvironment'
-          permission :edit_salt_environments, {:'foreman_salt/salt_environments' => [:update, :edit]},:resource_type => 'ForemanSalt::SaltEnvironment'
-          permission :destroy_salt_environments, {:'foreman_salt/salt_environments' => [:destroy]}, :resource_type => 'ForemanSalt::SaltEnvironment'
-        end
-
-        security_block :salt_modules do |map|
-          permission :create_salt_modules, {:'foreman_salt/salt_modules' => [:new, :create]}, :resource_type => 'ForemanSalt::SaltModule'
-          permission :view_salt_modules, {:'foreman_salt/salt_modules' => [:index, :show, :auto_complete_search]}, :resource_type => 'ForemanSalt::SaltModule'
-          permission :edit_salt_modules, {:'foreman_salt/salt_modules' => [:update, :edit]},:resource_type => 'ForemanSalt::SaltModule'
-          permission :destroy_salt_modules, {:'foreman_salt/salt_modules' => [:destroy]}, :resource_type => 'ForemanSalt::SaltModule'
-        end
-
-        security_block :salt_keys do |map|
-          permission :view_smart_proxies_salt_keys, {:'foreman_salt/salt_keys' => [:index]}, :resource_type => 'SmartProxy'
-          permission :destroy_smart_proxies_salt_keys, {:'foreman_salt/salt_keys' => [:destroy]},:resource_type => 'SmartProxy'
-          permission :edit_smart_proxies_salt_keys, {:'foreman_salt/salt_keys' => [:accept, :reject]}, :resource_type => 'SmartProxy'
-        end
-
-        security_block :salt_autosign do |map|
-          permission :destroy_smart_proxies_salt_autosign, {:'foreman_salt/salt_autosign' => [:destroy]}, :resource_type => 'SmartProxy'
-          permission :create_smart_proxies_salt_autosign, {:'foreman_salt/salt_autosign' => [:new, :create]}, :resource_type => 'SmartProxy'
-          permission :view_smart_proxies_salt_autosign, {:'foreman_salt/salt_autosign' => [:index]}, :resource_type => 'SmartProxy'
-        end
-
-        security_block :api do |map|
-          permission :create_reports, {:'foreman_salt/api/v2/jobs' => [:upload]}, :resource_type => 'Report'
+                           :caption => 'Salt',
+                           :after   => :common_parameters
+
+        # Permissions
+        security_block :foreman_salt do |_map|
+          permission :destroy_smart_proxies_salt_autosign,
+                     { :'foreman_salt/salt_autosign' => [:destroy],
+                       :'foreman_salt/api/v2/salt_autosign' => [:destroy] },
+                     :resource_type => 'SmartProxy'
+
+          permission :create_smart_proxies_salt_autosign,
+                     { :'foreman_salt/salt_autosign' => [:new, :create],
+                       :'foreman_salt/api/v2/salt_autosign' => [:create] },
+                     :resource_type => 'SmartProxy'
+
+          permission :view_smart_proxies_salt_autosign,
+                     { :'foreman_salt/salt_autosign' => [:index],
+                       :'foreman_salt/api/v2/salt_autosign' => [:index] },
+                     :resource_type => 'SmartProxy'
+
+          permission :create_salt_environments,
+                     { :'foreman_salt/salt_environments' => [:new, :create],
+                       :'foreman_salt/api/v2/salt_environments' => [:create] },
+                     :resource_type => 'ForemanSalt::SaltEnvironment'
+
+          permission :view_salt_environments,
+                     { :'foreman_salt/salt_environments' => [:index, :show, :auto_complete_search],
+                       :'foreman_salt/api/v2/salt_environments' => [:index, :show] },
+                     :resource_type => 'ForemanSalt::SaltEnvironment'
+
+          permission :edit_salt_environments,
+                     { :'foreman_salt/salt_environments' => [:update, :edit] },
+                     :resource_type => 'ForemanSalt::SaltEnvironment'
+
+          permission :destroy_salt_environments,
+                     { :'foreman_salt/salt_environments' => [:destroy],
+                       :'foreman_salt/api/v2/salt_environments' => [:destroy] },
+                     :resource_type => 'ForemanSalt::SaltEnvironment'
+
+          permission :create_reports,
+                     { :'foreman_salt/api/v2/jobs' => [:upload] },
+                     :resource_type => 'Report'
+
+          permission :saltrun_hosts,
+                     { :'foreman_salt/minions' => [:run] },
+                     :resource_type => 'Host'
+
+          permission :edit_hosts,
+                     { :'foreman_salt/api/v2/salt_minions' => [:update] },
+                     :resource_type => 'Host'
+
+          permission :view_hosts,
+                     { :'foreman_salt/minions' => [:node],
+                       :'foreman_salt/api/v2/salt_minions' => [:index, :show] },
+                     :resource_type => 'Host'
+
+          permission :view_smart_proxies_salt_keys,
+                     { :'foreman_salt/salt_keys' => [:index],
+                       :'foreman_salt/api/v2/salt_keys' => [:index] },
+                     :resource_type => 'SmartProxy'
+
+          permission :destroy_smart_proxies_salt_keys,
+                     { :'foreman_salt/salt_keys' => [:destroy],
+                       :'foreman_salt/api/v2/salt_keys' => [:destroy] },
+                     :resource_type => 'SmartProxy'
+
+          permission :edit_smart_proxies_salt_keys,
+                     { :'foreman_salt/salt_keys' => [:accept, :reject],
+                       :'foreman_salt/api/v2/salt_keys' => [:update] },
+                     :resource_type => 'SmartProxy'
+
+          permission :create_salt_modules,
+                     { :'foreman_salt/salt_modules' => [:new, :create],
+                       :'foreman_salt/api/v2/salt_states' => [:create] },
+                     :resource_type => 'ForemanSalt::SaltModule'
+
+          permission :view_salt_modules,
+                     { :'foreman_salt/salt_modules' => [:index, :show, :auto_complete_search],
+                       :'foreman_salt/api/v2/salt_states' => [:index, :show] },
+                     :resource_type => 'ForemanSalt::SaltModule'
+
+          permission :edit_salt_modules,
+                     { :'foreman_salt/salt_modules' => [:update, :edit] },
+                     :resource_type => 'ForemanSalt::SaltModule'
+
+          permission :destroy_salt_modules,
+                     { :'foreman_salt/salt_modules' => [:destroy],
+                       :'foreman_salt/api/v2/salt_states' => [:destroy] },
+                     :resource_type => 'ForemanSalt::SaltModule'
         end
 
+        ## Roles
         role 'Salt admin', [:saltrun_hosts, :create_salt_modules, :view_salt_modules, :edit_salt_modules, :destroy_salt_modules,
                             :view_smart_proxies_salt_keys, :destroy_smart_proxies_salt_keys, :edit_smart_proxies_salt_keys,
                             :create_smart_proxies_salt_autosign, :view_smart_proxies_salt_autosign, :destroy_smart_proxies_salt_autosign,
                             :create_salt_environments, :view_salt_environments, :edit_salt_environments, :destroy_salt_environments]
-
       end
     end
 
     config.to_prepare do
       begin
         ::FactImporter.register_fact_importer(:foreman_salt, ForemanSalt::FactImporter)
+        ::FactParser.register_fact_importer(:foreman_salt, ForemanSalt::FactParser)
 
         # Helper Extensions
         ::HostsHelper.send :include, ForemanSalt::HostsHelperExtensions
@@ -99,13 +161,8 @@ module ForemanSalt
 
         # Controller Extensions
         ::UnattendedController.send :include, ForemanSalt::Concerns::UnattendedControllerExtensions
-        ::HostsController.send  :include, ForemanSalt::Concerns::HostsControllerExtensions
-        ::HostsController.send  :include, ForemanSalt::Concerns::SmartProxyAuthExtensions
-        ::HostgroupsController.send  :include, ForemanSalt::Concerns::HostgroupsControllerExtensions
-
-        # API Extensions
-        ::Api::V2::HostsController.send :include, ForemanSalt::Concerns::SmartProxyAuthExtensions
-        ::Api::V2::ReportsController.send :include, ForemanSalt::Concerns::SmartProxyAuthExtensions
+        ::HostsController.send :include, ForemanSalt::Concerns::HostsControllerExtensions
+        ::HostgroupsController.send :include, ForemanSalt::Concerns::HostgroupsControllerExtensions
       rescue => e
         puts "ForemanSalt: skipping engine hook (#{e})"
       end

data/lib/foreman_salt/version.rb

@@ -1,3 +1,3 @@
 module ForemanSalt
-  VERSION = '1.1.1'
+  VERSION = '2.0.0'
 end

data/lib/tasks/foreman_salt_tasks.rake

@@ -8,7 +8,7 @@ namespace :foreman_salt do
                          "#{ForemanSalt::Engine.root}/test/**/*.rb"]
       end
     rescue
-      puts "Rubocop not loaded."
+      puts 'Rubocop not loaded.'
     end
 
     Rake::Task['rubocop_salt'].invoke
@@ -19,7 +19,7 @@ namespace :test do
   desc 'Test ForemanSalt'
   Rake::TestTask.new(:foreman_salt) do |t|
     test_dir = File.join(File.dirname(__FILE__), '../..', 'test')
-    t.libs << ['test',test_dir]
+    t.libs << ['test', test_dir]
     t.pattern = "#{test_dir}/**/*_test.rb"
     t.verbose = true
   end

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

@@ -0,0 +1,27 @@
+require 'test_plugin_helper'
+
+module ForemanSalt
+  class Api::V2::SaltAutosignControllerTest < ActionController::TestCase
+    setup do
+      @proxy = FactoryGirl.create(:smart_proxy, :with_salt_feature)
+      ProxyAPI::Salt.any_instance.stubs(:autosign_list).returns((%w(foo bar baz)))
+    end
+
+    test 'should get index' do
+      get :index, :smart_proxy_id => @proxy.id
+      assert_response :success
+    end
+
+    test 'should create autosign' do
+      ProxyAPI::Salt.any_instance.expects(:autosign_create).once.returns(true)
+      post :create, :smart_proxy_id => @proxy.id, :record => 'unicorn.example.com'
+      assert_response :success
+    end
+
+    test 'should delete autosign' do
+      ProxyAPI::Salt.any_instance.expects(:autosign_remove).once.returns(true)
+      delete :destroy, :smart_proxy_id => @proxy.id, :record => 'unicorn.example.com'
+      assert_response :success
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'test_plugin_helper'
+
+module ForemanSalt
+  class Api::V2::SaltEnvironmentsControllerTest < ActionController::TestCase
+    test 'should get index' do
+      get :index, {}
+      assert_response :success
+      assert_template 'api/v2/salt_environments/index'
+    end
+
+    test 'should show environment' do
+      environment = ForemanSalt::SaltEnvironment.create(:name => 'foo')
+      get :show, :id => environment.id
+      assert_response :success
+      assert_template 'api/v2/salt_environments/show'
+    end
+
+    test 'should create environment' do
+      post :create, :environment => { :name => 'unicorn' }
+      assert_response :success
+      assert ForemanSalt::SaltEnvironment.find_by_name('unicorn')
+      assert_template 'api/v2/salt_environments/create'
+    end
+
+    test 'should delete environment' do
+      environment = ForemanSalt::SaltEnvironment.create(:name => 'foo.bar.baz')
+      assert_difference('ForemanSalt::SaltEnvironment.count', -1) do
+        delete :destroy, :id => environment.id
+      end
+      assert_response :success
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'test_plugin_helper'
+
+module ForemanSalt
+  class Api::V2::SaltKeysControllerTest < ActionController::TestCase
+    setup do
+      @proxy = FactoryGirl.create(:smart_proxy, :with_salt_feature)
+
+      ProxyAPI::Salt.any_instance.stubs(:key_list).returns('saltstack.example.com' => { 'state' => 'unaccepted',
+                                                                                        'fingerprint' => '98:c2:63:c1:57:59:bc:bd:f1:ef:5a:38:b2:e9:71:c0' })
+    end
+
+    test 'should get index' do
+      get :index, :smart_proxy_id => @proxy.id
+      assert_response :success
+    end
+
+    test 'should update keys' do
+      ProxyAPI::Salt.any_instance.expects(:key_accept).once.returns(true)
+      put :update, :smart_proxy_id => @proxy.id, :name => 'saltstack.example.com', :key => { :state => 'accepted' }
+      assert_response :success
+    end
+
+    test 'should delete keys' do
+      ProxyAPI::Salt.any_instance.expects(:key_delete).once.returns(true)
+      delete :destroy, :smart_proxy_id => @proxy.id, :name => 'saltstack.example.com'
+      assert_response :success
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'test_plugin_helper'
+
+module ForemanSalt
+  class Api::V2::SaltStatesControllerTest < ActionController::TestCase
+    test 'should get index' do
+      get :index, {}
+      assert_response :success
+      assert_template 'api/v2/salt_states/index'
+    end
+
+    test 'should show state' do
+      state = ForemanSalt::SaltModule.create(:name => 'foo.bar.baz')
+      get :show, :id => state.id
+      assert_response :success
+      assert_template 'api/v2/salt_states/show'
+    end
+
+    test 'should create state' do
+      post :create, :state => { :name => 'unicorn' }
+      assert_response :success
+      assert ForemanSalt::SaltModule.find_by_name('unicorn')
+      assert_template 'api/v2/salt_states/create'
+    end
+
+    test 'should delete state' do
+      state = ForemanSalt::SaltModule.create(:name => 'foo.bar.baz')
+      assert_difference('ForemanSalt::SaltModule.count', -1) do
+        delete :destroy, :id => state.id
+      end
+      assert_response :success
+    end
+  end
+end

data/test/functional/minions_controller_test.rb

@@ -0,0 +1,18 @@
+require 'test_plugin_helper'
+
+module ForemanSalt
+  class MinionsControllerTest < ActionController::TestCase
+    test 'salt smart proxy should get salt external node' do
+      User.current = nil
+      Setting[:restrict_registered_smart_proxies] = true
+      Setting[:require_ssl_smart_proxies] = false
+
+      proxy = FactoryGirl.create :smart_proxy, :with_salt_feature
+      Resolv.any_instance.stubs(:getnames).returns([proxy.to_s])
+
+      host = FactoryGirl.create :host
+      get :node, :id => host, :format => 'yml'
+      assert_response :success
+    end
+  end
+end

data/test/integration/salt_environment_test.rb

@@ -2,7 +2,6 @@ require 'test_plugin_helper'
 
 module ForemanSalt
   class SaltEnvironmentTest < ActionDispatch::IntegrationTest
-
     test 'index page' do
       FactoryGirl.create_list :salt_environment, 50
       assert_index_page(salt_environments_path, 'Salt Environment', 'New Salt Environment')

data/test/integration/salt_keys_test.rb

@@ -6,12 +6,10 @@ module ForemanSalt
       @proxy = FactoryGirl.create :smart_proxy, :with_salt_feature
 
       ::ProxyAPI::Salt.any_instance.stubs(:key_list).returns(
-        {
-          'saltstack.example.com' => {'state'=>'accepted', 'fingerprint'=>'98:c2:63:c1:57:59:bc:bd:f1:ef:5a:38:b2:e9:71:c0'},
-          'saltclient01.example.com'=> {'state'=>'unaccepted', 'fingerprint'=>'98:c2:63:c1:57:59:bc:bd:f1:ef:5a:38:b2:e9:71:c1'},
-          'saltclient02.example.com'=> {'state'=>'unaccepted', 'fingerprint'=>'98:c2:63:c1:57:59:bc:bd:f1:ef:5a:38:b2:e9:71:c2'},
-          'saltclient03.example.com' => {'state'=>'rejected',   'fingerprint'=>'98:c2:63:c1:57:59:bc:bd:f1:ef:5a:38:b2:e9:71:c3'}
-        }
+        'saltstack.example.com'    => { 'state' => 'accepted',   'fingerprint' => '98:c2:63:c1:57:59:bc:bd:f1:ef:5a:38:b2:e9:71:c0' },
+        'saltclient01.example.com' => { 'state' => 'unaccepted', 'fingerprint' => '98:c2:63:c1:57:59:bc:bd:f1:ef:5a:38:b2:e9:71:c1' },
+        'saltclient02.example.com' => { 'state' => 'unaccepted', 'fingerprint' => '98:c2:63:c1:57:59:bc:bd:f1:ef:5a:38:b2:e9:71:c2' },
+        'saltclient03.example.com' => { 'state' => 'rejected',   'fingerprint' => '98:c2:63:c1:57:59:bc:bd:f1:ef:5a:38:b2:e9:71:c3' }
       )
     end
 

data/test/integration/salt_module_test.rb

@@ -2,7 +2,6 @@ require 'test_plugin_helper'
 
 module ForemanSalt
   class SaltModuleTest < ActionDispatch::IntegrationTest
-
     test 'index page' do
       FactoryGirl.create_list :salt_module, 50
       assert_index_page(salt_modules_path, 'Salt State', 'New Salt State')

data/test/unit/grains_centos.json

@@ -102,7 +102,10 @@
     "os_family": "RedHat",
     "operatingsystemrelease": "6.5",
     "gpus::0::vendor": "unknown",
-    "lsb_distrib_codename": "Final"
+    "lsb_distrib_codename": "Final",
+    "fqdn_ip4::0": "10.7.13.141",
+    "ip_interfaces::eth1::0": "1.2.3.4",
+    "hwaddr_interfaces::eth1": "DE:AD:BE:EF:07:13"
   },
   "name": "saltclient01.example.com"
 }

data/test/unit/grains_importer_test.rb

@@ -6,33 +6,59 @@ module ForemanSalt
       User.current = User.find_by_login 'admin'
       Setting[:create_new_host_when_facts_are_uploaded] = true
 
-      # I don't even know, the plug-in successfully registers the importer
-      # in development, and even on the Rails test console but not here
-      # in the test itself...
-      ::FactImporter.stubs(:importer_for).returns(ForemanSalt::FactImporter)
+      Operatingsystem.where(:name => 'CentOS', :major => '6', :minor => '5').delete_all
 
       grains = JSON.parse(File.read(File.join(Engine.root, 'test', 'unit', 'grains_centos.json')))
-      @host  = grains['name']
-      @facts = grains['facts']
+      host  = grains['name']
+      facts = HashWithIndifferentAccess.new(grains['facts'])
+
+      (@imported_host, _) = ::Host::Managed.import_host_and_facts host, facts
     end
 
     test 'importing salt grains creates a host' do
-      refute Host.find_by_name(@host)
-      ::Host::Managed.import_host_and_facts @host, @facts
-      assert Host.find_by_name(@host)
+      assert @imported_host
     end
 
     test 'grains are successfully imported for a host' do
-      (host, _) = ::Host::Managed.import_host_and_facts @host, @facts
-      assert_equal 'CentOS', host.facts_hash['operatingsystem']
+      assert_equal 'CentOS', @imported_host.facts_hash['operatingsystem']
     end
 
     test 'nested facts have valid parents' do
-      (host, _) = ::Host::Managed.import_host_and_facts @host, @facts
       parent = ::FactName.find_by_name('cpu_flags')
-      children = host.fact_values.with_fact_parent_id(parent)
+      children = @imported_host.fact_values.with_fact_parent_id(parent)
       assert_not_empty children
       assert_empty children.map(&:fact_name).reject { |fact| fact.name =~ /\Acpu_flags#{FactName::SEPARATOR}[0-9]+/ }
     end
+
+    # Parser
+    test 'imported host has operating system' do
+      assert_equal @imported_host.os.to_label, 'CentOS 6.5'
+    end
+
+    test 'imported host operating system has deduced family' do
+      assert_equal @imported_host.os.family, 'Redhat'
+    end
+
+    test 'imported host has hardware model' do
+      assert_equal @imported_host.model.name, 'KVM'
+    end
+
+    test 'imported host has architecture' do
+      assert_equal @imported_host.arch.name, 'x86_64'
+    end
+
+    test 'imported host has primary ip' do
+      assert_equal @imported_host.ip, '10.7.13.141'
+    end
+
+    test 'imported host has primary mac' do
+      assert_equal @imported_host.mac, '52:54:00:35:30:2a'
+    end
+
+    test 'imported host has additional interface' do
+      nic = @imported_host.interfaces.find_by_identifier('eth1')
+      assert_equal nic.mac, 'de:ad:be:ef:07:13'
+      assert_equal nic.ip, '1.2.3.4'
+    end
   end
 end

data/test/unit/salt_keys_test.rb

@@ -10,12 +10,10 @@ class SaltKeysTest < ActiveSupport::TestCase
     @proxy = OpenStruct.new(:id => 1, :url => 'http://dummy.example.com:9090')
 
     ProxyAPI::Salt.any_instance.stubs(:key_list).returns(
-      {
-        'saltstack.example.com'    => {'state'=>'accepted',   'fingerprint'=>'98:c2:63:c1:57:59:bc:bd:f1:ef:5a:38:b2:e9:71:c0'},
-        'saltclient01.example.com' => {'state'=>'unaccepted', 'fingerprint'=>'98:c2:63:c1:57:59:bc:bd:f1:ef:5a:38:b2:e9:71:c1'},
-        'saltclient02.example.com' => {'state'=>'unaccepted', 'fingerprint'=>'98:c2:63:c1:57:59:bc:bd:f1:ef:5a:38:b2:e9:71:c2'},
-        'saltclient03.example.com' => {'state'=>'rejected',   'fingerprint'=>'98:c2:63:c1:57:59:bc:bd:f1:ef:5a:38:b2:e9:71:c3'}
-      }
+      'saltstack.example.com'    => { 'state' => 'accepted',   'fingerprint' => '98:c2:63:c1:57:59:bc:bd:f1:ef:5a:38:b2:e9:71:c0' },
+      'saltclient01.example.com' => { 'state' => 'unaccepted', 'fingerprint' => '98:c2:63:c1:57:59:bc:bd:f1:ef:5a:38:b2:e9:71:c1' },
+      'saltclient02.example.com' => { 'state' => 'unaccepted', 'fingerprint' => '98:c2:63:c1:57:59:bc:bd:f1:ef:5a:38:b2:e9:71:c2' },
+      'saltclient03.example.com' => { 'state' => 'rejected',   'fingerprint' => '98:c2:63:c1:57:59:bc:bd:f1:ef:5a:38:b2:e9:71:c3' }
     )
   end