foreman_salt 0.0.2

data/app/overrides/foreman/salt_modules/_host_tab_pane.html.erb

@@ -0,0 +1,22 @@
+<% @inherited_salt_modules = [] if @inherited_salt_modules.blank? %>
+<div class="tab-pane" id="salt_modules">
+  <div class="row">
+    <div class="col-md-4">
+       <h3>Inherited Modules</h3>
+       <ul>
+       <% @inherited_salt_modules.sort.each do |salt_module| -%>
+         <li title="Inherited from hostgroup"><%= salt_module.name -%></li>
+       <% end -%>
+       </ul>
+     </div>
+     <div class="col-md-8">
+       <h3>Salt Modules</h3>
+       <% if @inherited_salt_modules.blank? -%>
+         <%= multiple_selects f, :salt_module, ::ForemanSalt::SaltModule, @salt_modules.try(:map, &:id), :label => "" %>
+       <% else -%>
+         <%= multiple_selects f, :salt_module, ::ForemanSalt::SaltModule.where('id NOT IN (?)', @inherited_salt_modules.map(&:id)), @salt_modules.try(:map, &:id), :label => "" %>
+       <% end -%>
+     </div>
+   </div>
+</div>
+

data/app/overrides/salt_modules_selector.rb

@@ -0,0 +1,19 @@
+Deface::Override.new(:virtual_path => "hosts/_form",
+  :name => "add_salt_modules_tab_to_host",
+  :insert_after => 'li.active',
+  :partial => '../overrides/foreman/salt_modules/host_tab')
+
+Deface::Override.new(:virtual_path => "hosts/_form",
+  :name => "add_salt_modules_tab_pane_to_host",
+  :insert_before => 'div#puppet_klasses',
+  :partial => '../overrides/foreman/salt_modules/host_tab_pane')
+  
+Deface::Override.new(:virtual_path => "hostgroups/_form",
+  :name => "add_salt_modules_tab_to_hg",
+  :insert_after => 'li.active',
+  :partial => '../overrides/foreman/salt_modules/host_tab')
+
+Deface::Override.new(:virtual_path => "hostgroups/_form",
+  :name => "add_salt_modules_tab_pane_to_hg",
+  :insert_before => 'div#puppet_klasses',
+  :partial => '../overrides/foreman/salt_modules/host_tab_pane')

data/app/overrides/salt_proxy_selector.rb

@@ -0,0 +1,13 @@
+selector_text = "<%= select_f f, :salt_proxy_id, SmartProxy.unscoped.with_features('Salt').with_taxonomy_scope(@location,@organization, :path_ids), :id, :name,
+                                 { :include_blank => blank_or_inherit_f(f, :salt_proxy) },
+                                 { :label         => _('Salt Master') } %>"
+
+Deface::Override.new(:virtual_path  => "hosts/_form",
+                     :name          => "add_salt_proxy_to_host",
+                     :insert_bottom => 'div#primary',
+                     :text          =>  selector_text)
+
+Deface::Override.new(:virtual_path  => "hostgroups/_form",
+                     :name          => "add_salt_proxy_to_hostgroup",
+                     :insert_bottom => 'div#primary',
+                     :text          =>  selector_text)

data/app/services/foreman_salt/fact_importer.rb

@@ -0,0 +1,108 @@
+module ForemanSalt
+  class FactImporter < ::FactImporter
+    def fact_name_class
+      ForemanSalt::FactName
+    end
+
+    def self.support_background
+      true
+    end
+
+    private
+
+    attr_accessor :original_facts
+
+    def add_new_facts
+      @counters[:added] = 0
+      add_missing_facts(unsparse(original_facts))
+      logger.debug("Merging facts for '#{host}': added #{@counters[:added]} facts")
+    end
+
+    def add_missing_facts(tree_hash, parent = nil, prefix = '')
+      tree_hash.each do |name, value|
+        name_with_prefix = prefix.empty? ? name : prefix + FactName::SEPARATOR + name
+
+        compose = value.is_a?(Hash)
+        if fact_names[name_with_prefix].present?
+          fact_name_id = fact_names[name_with_prefix]
+        else
+          fact_name_id = fact_name_class.create!(:name      => name_with_prefix,
+                                                 :parent_id => parent,
+                                                 :compose   => compose).id
+        end
+
+        if compose
+          add_fact(name_with_prefix, nil, fact_name_id)
+          add_missing_facts(value, fact_name_id, name_with_prefix)
+        else
+          add_fact(name_with_prefix, value, fact_name_id)
+        end
+      end
+    end
+
+    def add_fact(name, value, fact_name_id)
+      if facts_to_create.include?(name)
+        host.fact_values.send(method,
+                              :value => value, :fact_name_id => fact_name_id)
+        @counters[:added] += 1
+      end
+    end
+
+    def facts_to_create
+      @facts_to_create ||= facts.keys - db_facts.keys
+    end
+
+    def fact_names
+      @fact_names ||= fact_name_class.maximum(:id, :group => 'name')
+    end
+
+    # if the host does not exists yet, we don't have an host_id to use the fact_values table.
+    def method
+      @method ||= host.new_record? ? :build : :create!
+    end
+
+    def normalize(facts)
+      @original_facts = super(facts)
+      @facts = completify(@original_facts)
+    end
+
+    def completify(hash)
+      new_facts = hash.dup
+      hash.each do |fact_name, value|
+        name_parts = fact_name.split(FactName::SEPARATOR)
+
+        name_parts.inject([]) do |memo, name|
+          memo           = memo + [name]
+          key            = memo.join(FactName::SEPARATOR)
+          new_facts[key] ||= name_parts == memo ? value : nil
+          memo
+        end
+      end
+      new_facts
+    end
+
+    def sort_by_key(hash)
+      hash.sort_by { |k, v| k.to_s }
+    end
+
+    def sparse(hash, options={})
+      hash.map do |k, v|
+        prefix = (options.fetch(:prefix, [])+[k])
+        next Sparsify::sparse(v, options.merge(:prefix => prefix)) if v.is_a? Hash
+        { prefix.join(options.fetch(:separator, FactName::SEPARATOR)) => v }
+      end.reduce(:merge) || Hash.new
+    end
+
+    def unsparse(hash, options={})
+      ret = Hash.new
+      sparse(hash).each do |k, v|
+        current            = ret
+        key                = k.to_s.split(options.fetch(:separator, FactName::SEPARATOR))
+        current            = (current[key.shift] ||= Hash.new) until (key.size<=1)
+        current[key.first] = v
+      end
+      return ret
+    end
+  end
+end
+

data/app/services/foreman_salt/smart_proxies/salt_keys.rb

@@ -0,0 +1,68 @@
+module ForemanSalt
+  class SmartProxies::SaltKeys
+
+    attr_reader :name, :state, :fingerprint, :smart_proxy_id
+
+     def initialize opts
+       @name, @state, @fingerprint, @smart_proxy_id = opts.flatten
+     end
+
+       class << self
+
+         def all(proxy)
+           raise ::Foreman::Exception.new(N_("Must specify a Smart Proxy to use")) if proxy.nil?
+
+           unless (keys = Rails.cache.read("saltkeys_#{proxy.id}"))
+             api = ProxyAPI::Salt.new({:url => proxy.url})
+             keys = api.key_list.map do |name, properties|
+               new([name.strip, properties['state'], properties['fingerprint'], proxy.id])
+             end.compact
+
+             Rails.cache.write("saltkeys_#{proxy.id}", keys, {:expires_in => 1.minute }) if Rails.env.production?
+           end
+           keys
+         end
+
+         def find(proxy, name)
+           all(proxy).select{|c| c.name == name}.first
+         end
+
+         def find_by_state(proxy, state)
+           all(proxy).select{|c| c.state == state}
+         end
+       end
+
+    def accept
+      raise ::Foreman::Exception.new(N_("unable to re-accept an accepted key")) unless state == "unaccepted"
+      proxy = SmartProxy.find(smart_proxy_id)
+      Rails.cache.delete("saltkeys_#{proxy.id}") if Rails.env.production?
+      ProxyAPI::Salt.new({:url => proxy.url}).key_accept name
+    end
+
+    def reject
+      raise ::Foreman::Exception.new(N_("unable to reject an accepted key")) unless state == "unaccepted"
+      proxy = SmartProxy.find(smart_proxy_id)
+      Rails.cache.delete("saltkeys_#{proxy.id}") if Rails.env.production?
+      ProxyAPI::Salt.new({:url => proxy.url}).key_reject name
+    end
+
+
+    def delete
+      proxy = SmartProxy.find(smart_proxy_id)
+      Rails.cache.delete("saltkeys_#{proxy.id}") if Rails.env.production?
+      ProxyAPI::Salt.new({:url => proxy.url}).key_delete name
+    end
+
+    def to_param
+      name
+    end
+    
+    def to_s
+      name
+    end
+
+    def <=> other
+      self.name <=> other.name
+    end
+  end
+end

data/app/views/foreman_salt/salt_autosign/_form.html.erb

@@ -0,0 +1,8 @@
+<%= form_tag url_for(:controller => 'foreman_salt/salt_autosign', :smart_proxy_id => @proxy, :action => 'index') do |f| %>
+  <div class="clearfix">
+    <div class="input">
+    <%= label_tag(_("Name")) %> <%= text_field_tag(:id, "", :size => 60) %> <%= submit_tag _('Save'), :class => "btn btn-success" %>
+    </div>
+  </div>
+<% end %>
+

data/app/views/foreman_salt/salt_autosign/index.html.erb

@@ -0,0 +1,21 @@
+<% title _("Autosign entries for %s") % @proxy %>
+
+<% title_actions display_link_if_authorized(_("Keys"), hash_for_smart_proxy_salt_keys_path), display_link_if_authorized(_("New"), {:controller => 'foreman_salt/salt_autosign', :action => 'new', :smart_proxy_id => @proxy, :auth_object => @proxy, :permission => 'create_smart_proxies_salt_keys'}) %>
+
+<table class='table table-bordered table-striped table-condensed'>
+  <tr>
+    <th><%= _("Name") %></th>
+    <th></th>
+  </tr>
+  <% @autosign.each do |key| %>
+      <tr>
+        <td><%= key%> </td>
+        <td>
+          <%= action_buttons(display_delete_if_authorized(hash_for_smart_proxy_salt_autosign_path.merge(:smart_proxy_id => @proxy, :id => key), :class => 'delete')) %>
+        </td>
+      </tr>
+  <% end %>
+</table>
+
+<%= page_entries_info @autosign %>
+<%= will_paginate @autosign %>

data/app/views/foreman_salt/salt_autosign/new.html.erb

@@ -0,0 +1,3 @@
+<% title _("New Autosign Entry") %>
+
+<%= render :partial => 'form' %>

data/app/views/foreman_salt/salt_keys/index.erb

@@ -0,0 +1,34 @@
+<% title _("Salt Keys on %s") % @proxy.name %>
+<% search_bar _("Filter %s") % salt_keys_state_filter %>
+
+<% title_actions display_link_if_authorized(_("Autosign"), hash_for_smart_proxy_salt_autosign_index_path) %>
+
+<table class='table table-bordered table-striped table-condensed'>
+  <tr>
+    <th><%= _("Key Name") %></th>
+    <th><%= _("State") %></th>
+    <th><%= _("Fingerprint") %></th>
+    <th></th>
+  </tr>
+  <% @keys.each do |key| %>
+      <tr>
+        <td><%= key.name %> </td>
+        <td><%= _(key.state.humanize) %></td>
+        <td><%= key.fingerprint %></td>
+        <td>
+          <%= action_buttons(
+                  if key.state == "unaccepted"
+                    [display_link_if_authorized(_("Accept"), hash_for_smart_proxy_salt_key_accept_path.merge(:state => params[:state], :salt_key_id => key)),
+                    display_link_if_authorized(_("Reject"), hash_for_smart_proxy_salt_key_reject_path.merge(:state => params[:state], :salt_key_id => key))]
+                  end,
+                  display_delete_if_authorized(hash_for_smart_proxy_salt_key_path(:smart_proxy_id => @proxy, :id => key, :state => params[:state], :class => 'delete'))
+                  )
+          %>
+        </td>
+      </tr>
+  <% end %>
+</table>
+
+<%= page_entries_info @keys  %>
+<%= will_paginate @keys %>
+

data/app/views/foreman_salt/salt_modules/_form.html.erb

@@ -0,0 +1,15 @@
+<%= form_for @salt_module, :url => (@salt_module.new_record? ? salt_modules_path : salt_module_path(:id => @salt_module.id)) do |f| %>
+  <%= base_errors_for @salt_module %>
+  <ul class="nav nav-tabs" data-tabs="tabs">
+    <li class="active"><a href="#primary" data-toggle="tab"><%= _('Salt Modules') %></a></li>
+  </ul>
+
+  <div class="tab-content">
+    <div class="tab-pane active" id="primary">
+      <%= text_f f, :name %>
+    </div>
+  </div>
+
+  <%= submit_or_cancel f %>
+<% end %>
+

data/app/views/foreman_salt/salt_modules/edit.html.erb

@@ -0,0 +1,4 @@
+<% title(_("Edit Salt Module %s") % @salt_module) %>
+
+<%= render :partial => 'form' %>
+

data/app/views/foreman_salt/salt_modules/index.html.erb

@@ -0,0 +1,23 @@
+<% title _("Salt modules") %>
+
+<% title_actions button_group(display_link_if_authorized(_("New Salt module"), hash_for_new_salt_module_path)) %>
+
+<table class="table table-bordered table-striped">
+  <tr>
+    <th><%= sort :name, :as => s_("SaltModule|Name") %></th>
+    <th></th>
+  </tr>
+  <% for salt_module in @salt_modules %>
+    <tr>
+      <td><%=link_to_if_authorized h(salt_module.name), hash_for_edit_salt_module_path(:id => salt_module).merge(:auth_object => salt_module, :authorizer => authorizer) %></td>
+      <td>
+        <%= action_buttons(display_delete_if_authorized hash_for_salt_module_path(:id => salt_module).merge(:auth_object => salt_module, :authorizer => authorizer),
+                            :confirm => _("Delete %s?") % salt_module.name) %>
+      </td>
+    </tr>
+  <% end %>
+</table>
+
+<%= page_entries_info @salt_modules %>
+<%= will_paginate @salt_modules %>
+

data/app/views/foreman_salt/salt_modules/new.html.erb

@@ -0,0 +1,4 @@
+<% title _("New Salt module") %>
+
+<%= render :partial => 'form' %>
+

data/config/routes.rb

@@ -0,0 +1,32 @@
+Rails.application.routes.draw do
+
+  scope :salt, :path => '/salt' do
+    match "/node/:name" => 'hosts#salt_external_node', :constraints => { :name => /[^\.][\w\.-]+/ }
+
+    resources :salt_modules, :controller => 'foreman_salt/salt_modules' do 
+      collection do
+        get 'auto_complete_search'
+      end
+    end
+  end
+
+  constraints(:smart_proxy_id => /[^\/]+/) do
+    resources :smart_proxies, :except => [:show] do
+      constraints(:id => /[^\/]+/) do
+        resources :salt_autosign, :only => [:index, :destroy, :create, :new], :controller => 'foreman_salt/salt_autosign'
+        resources :salt_keys, :only => [:index, :destroy], :controller => 'foreman_salt/salt_keys' do
+          get :accept
+          get :reject
+        end
+      end
+    end
+  end
+
+  constraints(:id => /[^\/]+/) do
+    resources :hosts do
+      member do
+        get :saltrun
+      end
+    end
+  end
+end

data/db/migrate/20140813081913_add_salt_proxy_to_host_and_host_group.rb

@@ -0,0 +1,12 @@
+class AddSaltProxyToHostAndHostGroup < ActiveRecord::Migration
+  def self.up
+    add_column :hosts, :salt_proxy_id, :integer
+    add_column :hostgroups, :salt_proxy_id, :integer
+  end
+
+  def self.down
+    remove_column :hosts, :salt_proxy_id
+    remove_column :hostgroups, :salt_proxy_id
+  end
+
+end

data/db/migrate/20140817210214_create_salt_modules.rb

@@ -0,0 +1,20 @@
+class CreateSaltModules < ActiveRecord::Migration
+  def self.up
+    create_table :salt_modules do |t|
+      t.string      :name, :default => "", :null => false
+      t.timestamps
+    end
+
+    create_table 'hosts_salt_modules', :id => false do |t|
+      t.column :host_id, :integer
+      t.column :salt_module_id, :integer
+    end
+
+    add_index :salt_modules, :name, :unique => true
+  end
+
+  def self.down
+    drop_table :salt_modules
+    drop_table :hosts_salt_modules
+  end
+end

data/db/migrate/20140829210214_add_salt_modules_to_hostgroups.rb

@@ -0,0 +1,12 @@
+class AddSaltModulesToHostgroups < ActiveRecord::Migration
+  def self.up
+    create_table 'hostgroups_salt_modules', :id => false do |t|
+      t.column :hostgroup_id, :integer
+      t.column :salt_module_id, :integer
+    end
+  end
+
+  def self.down
+    drop_table :hostgroups_salt_modules
+  end
+end

data/db/seeds.d/75-salt-seeds.rb

@@ -0,0 +1,31 @@
+# Create feature for Smart Proxy
+Feature.find_or_create_by_name("Salt")
+
+# Seed our permissions
+permissions = [
+  %w(Host saltrun_hosts),
+  %w(Host view_hosts),
+  %w(ForemanSalt::SaltModule create_salt_modules),
+  %w(ForemanSalt::SaltModule view_salt_modules),
+  %w(ForemanSalt::SaltModule edit_salt_modules),
+  %w(ForemanSalt::SaltModule destroy_salt_modules),
+  %w(SmartProxy view_smart_proxies_salt_keys),
+  %w(SmartProxy destroy_smart_proxies_salt_keys),
+  %w(SmartProxy edit_smart_proxies_salt_keys),
+  %w(SmartProxy destroy_smart_proxies_salt_autosign),
+  %w(SmartProxy create_smart_proxies_salt_autosign),
+  %w(SmartProxy view_smart_proxies_salt_autosign),
+]
+
+permissions.each do |resource, permission|
+  Permission.find_or_create_by_resource_type_and_name resource, permission
+end
+
+# Add new viewing permissions to Viewer role
+viewer = Role.find_by_name('Viewer')
+
+if viewer
+  [:view_smart_proxies_salt_keys, :view_smart_proxies_salt_autosign, :view_salt_modules].each do |permission|
+    viewer.add_permissions!([permission]) unless viewer.permissions.include? Permission.find_by_name(permission)
+  end
+end

data/lib/foreman_salt/engine.rb

@@ -0,0 +1,90 @@
+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"]
+    config.autoload_paths += Dir["#{config.root}/app/overrides"]
+    config.autoload_paths += Dir["#{config.root}/app/services"]
+    config.autoload_paths += Dir["#{config.root}/app/lib"]
+
+    # Add any db migrations
+    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|
+      Foreman::Plugin.register :foreman_salt do
+        requires_foreman '>= 1.6'
+
+        menu :top_menu, :salt,
+          :url_hash => {:controller => :'foreman_salt/salt_modules', :action => :index },
+          :caption  => 'Modules',
+          :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_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
+
+        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]
+        
+      end
+    end
+
+    config.to_prepare do
+      begin
+        ::FactImporter.register_fact_importer(:foreman_salt, ForemanSalt::FactImporter)
+
+        # Helper Extensions
+        ::HostsHelper.send :include, ForemanSalt::HostsHelperExtensions
+        ::SmartProxiesHelper.send :include, ForemanSalt::SmartProxiesHelperExtensions
+
+        # Model Extensions
+        ::Host::Managed.send :include, ForemanSalt::Concerns::HostManagedExtensions
+        ::Host::Managed.send :include, ForemanSalt::Orchestration::Salt
+        ::Hostgroup.send :include, ForemanSalt::Concerns::HostgroupExtensions
+
+        # 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
+      rescue => e
+        puts "ForemanSalt: skipping engine hook (#{e.to_s})"
+      end
+    end
+  end
+end

data/lib/foreman_salt/version.rb

@@ -0,0 +1,3 @@
+module ForemanSalt
+  VERSION = "0.0.2"
+end

data/lib/foreman_salt.rb

@@ -0,0 +1,4 @@
+require "foreman_salt/engine"
+
+module ForemanSalt
+end

data/lib/tasks/foreman_salt_tasks.rake

@@ -0,0 +1,31 @@
+# Tasks
+namespace :foreman_salt do
+  namespace :example do
+    desc 'Example Task'
+    task :task => :environment do
+      # Task goes here
+    end
+  end
+end
+
+# Tests
+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.pattern = "#{test_dir}/**/*_test.rb"
+    t.verbose = true
+  end
+end
+
+Rake::Task[:test].enhance do
+  Rake::Task['test:foreman_salt'].invoke
+end
+
+load 'tasks/jenkins.rake'
+if Rake::Task.task_defined?(:'jenkins:setup')
+  Rake::Task["jenkins:unit"].enhance do
+    Rake::Task['test:foreman_salt'].invoke
+  end
+end

data/test/factories/foreman_salt_factories.rb

@@ -0,0 +1,32 @@
+FactoryGirl.define do
+  factory :smart_proxy, :class => "::SmartProxy" do
+    sequence(:name) { |n| "proxy#{n}" }
+    sequence(:url)  { |n| "http://proxy#{n}.example.com:9090" }
+
+    trait :with_salt_feature do
+      features        { [::Feature.find_or_create_by_name('Salt')] }
+    end
+  end
+
+  factory :salt_module, :class => "ForemanSalt::SaltModule" do
+    sequence(:name) { |n| "module#{n}" }
+  end
+end
+
+FactoryGirl.modify do
+  factory :host do
+    trait :with_salt_proxy do
+      salt_proxy { FactoryGirl.create :smart_proxy, :with_salt_feature }
+    end
+  end
+
+  factory :hostgroup do
+    trait :with_salt_proxy do
+      salt_proxy { FactoryGirl.create :smart_proxy, :with_salt_feature }
+    end
+
+    trait :with_salt_modules do
+      salt_modules { FactoryGirl.create_list :salt_module, 10 }
+    end
+  end
+end

data/test/functional/hosts_controller_test.rb

@@ -0,0 +1,17 @@
+require 'test_plugin_helper'
+
+class HostsControllerTest < ActionController::TestCase
+  test 'salt smart proxy should get salt external node' do
+    User.current = nil
+    Setting[:restrict_registered_puppetmasters] = true
+    Setting[:require_ssl_puppetmasters] = false
+
+
+    proxy = FactoryGirl.create :smart_proxy, :with_salt_feature
+    Resolv.any_instance.stubs(:getnames).returns([proxy.to_s])
+
+    host = FactoryGirl.create :host
+    get :salt_external_node, {:name => host.name, :format => "yml"}
+    assert_response :success
+  end
+end