foreman_discovery 1.0.0.rc1

data/test/foreman_app/test/functional/statistics_controller_test.rb

@@ -0,0 +1,21 @@
+require 'test_helper'
+
+class StatisticsControllerTest < ActionController::TestCase
+
+  test 'user with viewer rights should succeed in viewing statistics' do
+    @request.session[:user] = users(:one).id
+    users(:one).roles = [Role.find_by_name('Anonymous'), Role.find_by_name('Viewer')]
+    get :index, {}, set_session_user
+    assert_response :success
+  end
+
+  test 'index_json' do
+    get :index, {:format => "json"}, set_session_user
+    assert_response :success
+    stats = ActiveSupport::JSON.decode(@response.body)
+    assert stats.is_a?(Hash)
+    %w{os_count arch_count env_count klass_count cpu_count model_count mem_size mem_free swap_size swap_free}.each do |stat|
+          assert_not_nil stats["statistics"][stat]
+    end
+  end
+end

data/test/foreman_app/test/functional/subnets_controller_test.rb

@@ -0,0 +1,89 @@
+require 'test_helper'
+
+class SubnetsControllerTest < ActionController::TestCase
+  def test_index
+    get :index, {} , set_session_user
+    assert_template 'index'
+  end
+
+  def test_index_json
+    get :index, {:format => "json"} , set_session_user
+    subnets = ActiveSupport::JSON.decode(@response.body)
+    assert subnets.is_a?(Array)
+    assert_response :success
+  end
+
+  def test_new
+    get :new, {}, set_session_user
+    assert_template 'new'
+  end
+
+  def test_create_invalid
+    Subnet.any_instance.stubs(:valid?).returns(false)
+    post :create, {}, set_session_user
+    assert_template 'new'
+  end
+
+  def test_create_valid
+    Subnet.any_instance.stubs(:valid?).returns(true)
+    post :create, {:subnet => {:network => "192.168.0.1", :mask => "255.255.255.0"}}, set_session_user
+    assert_redirected_to subnets_url
+  end
+
+  def test_create_valid_json
+    Subnet.any_instance.stubs(:valid?).returns(true)
+    post :create, {:format => "json", :subnet => {:network => "192.168.0.1", :mask => "255.255.255.0"}}, set_session_user
+    subnet = ActiveSupport::JSON.decode(@response.body)
+    assert_response :created
+  end
+
+  def test_edit
+    get :edit, {:id => Subnet.first}, set_session_user
+    assert_template 'edit'
+  end
+
+  def test_update_invalid
+    Subnet.any_instance.stubs(:valid?).returns(false)
+    put :update, {:id => Subnet.first}, set_session_user
+    assert_template 'edit'
+  end
+
+  def test_update_valid
+    Subnet.any_instance.stubs(:valid?).returns(true)
+    put :update, {:id => Subnet.first}, set_session_user
+    assert_redirected_to subnets_url
+  end
+
+  def test_update_valid_json
+    Subnet.any_instance.stubs(:valid?).returns(true)
+    put :update, {:format => "json", :id => Subnet.first}, set_session_user
+    subnet = ActiveSupport::JSON.decode(@response.body)
+    assert_response :ok
+  end
+
+  def test_should_not_destroy_if_used_by_hosts
+    subnet = subnets(:one)
+    delete :destroy, {:id => subnet}, set_session_user
+    assert_redirected_to subnets_url
+    assert Subnet.exists?(subnet.id)
+  end
+
+  def test_destroy
+    subnet = Subnet.first
+    subnet.hosts.clear
+    subnet.interfaces.clear
+    delete :destroy, {:id => subnet}, set_session_user
+    assert_redirected_to subnets_url
+    assert !Subnet.exists?(subnet.id)
+  end
+
+  def test_destroy_json
+    subnet = Subnet.first
+    subnet.hosts.clear
+    subnet.interfaces.clear
+    delete :destroy, {:format => "json", :id => subnet}, set_session_user
+    subnet = ActiveSupport::JSON.decode(@response.body)
+    assert_response :ok
+    assert !Subnet.exists?(:id => subnet['id'])
+  end
+end

data/test/foreman_app/test/functional/tasks_controller_test.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+class TasksControllerTest < ActionController::TestCase
+  # Replace this with your real tests.
+  test "the truth" do
+    assert true
+  end
+end

data/test/foreman_app/test/functional/unattended_controller_test.rb

@@ -0,0 +1,141 @@
+require 'test_helper'
+
+class UnattendedControllerTest < ActionController::TestCase
+  test "should get a kickstart" do
+    @request.env["HTTP_X_RHN_PROVISIONING_MAC_0"] = "eth0 #{hosts(:redhat).mac}"
+    get :kickstart
+    assert_response :success
+  end
+
+  test "should get a kickstart even if not using the first NIC" do
+    @request.env["HTTP_X_RHN_PROVISIONING_MAC_0"] = "unused NIC"
+    @request.env["HTTP_X_RHN_PROVISIONING_MAC_3"] = "eth4 #{hosts(:redhat).mac}"
+    get :kickstart
+    assert_response :success
+  end
+
+  test "should get a kickstart even if we are behind a loadbalancer" do
+    @request.env["HTTP_X_FORWARDED_FOR"] = hosts(:redhat).ip
+    @request.env["REMOTE_ADDR"] = "127.0.0.1"
+    get :kickstart
+    assert_response :success
+  end
+
+  test "should get a preseed finish script" do
+    @request.env["REMOTE_ADDR"] = hosts(:ubuntu).ip
+    get :preseed_finish
+    assert_response :success
+  end
+
+  test "should get a preseed finish script with multiple ips in the request header" do
+    @request.env["REMOTE_ADDR"] = [hosts(:ubuntu).ip, '1.2.3.4']
+    get :preseed_finish
+    assert_response :success
+  end
+
+  test "should get a preseed" do
+    @request.env["REMOTE_ADDR"] = hosts(:ubuntu).ip
+    get :preseed
+    assert_response :success
+  end
+
+  test "unattended files content type should be text/plain" do
+    @request.env["REMOTE_ADDR"] = hosts(:ubuntu).ip
+    get :preseed
+    assert_response :success
+    assert @response.headers["Content-Type"].match("text/plain")
+  end
+
+  test "should support spoof" do
+    get :preseed, {:spoof => hosts(:ubuntu).ip}, set_session_user
+    assert_response :success
+  end
+
+  test "should render spoof when user is not logged in" do
+    get :preseed, {:spoof => hosts(:ubuntu).ip}
+    assert_response :redirect
+  end
+
+  test "should provide pxe config for redhat" do
+    get :pxe_kickstart_config, {:spoof => hosts(:redhat).ip}, set_session_user
+    assert_response :success
+  end
+
+  test "should provide pxe config for debian" do
+    get :pxe_debian_config, {:spoof => hosts(:ubuntu).ip}, set_session_user
+    assert_response :success
+  end
+
+  test "should accept built notifications" do
+    @request.env["REMOTE_ADDR"] = hosts(:ubuntu).ip
+    get :built
+    assert_response :created
+    host = Host.find_by_ip(hosts(:ubuntu).ip)
+    assert_equal host.build,false
+  end
+
+  test "should not provide unattened files to hosts which are not in built state" do
+    @request.env["HTTP_X_RHN_PROVISIONING_MAC_0"] = "eth0 #{hosts(:redhat).mac}"
+    get :built
+    assert_response :created
+    get :kickstart
+    assert_response :method_not_allowed
+  end
+
+  test "should not provide unattended files to hosts which we don't know about" do
+    get :kickstart
+    assert_response :not_found
+  end
+
+  test "should not provide unattended files to hosts which don't have an assign os" do
+    setup_users
+
+    hosts(:otherfullhost).update_attribute(:operatingsystem_id, nil)
+    @request.env["HTTP_X_RHN_PROVISIONING_MAC_0"] = "eth0 #{hosts(:otherfullhost).mac}"
+    get :kickstart
+    assert_response :conflict
+  end
+
+  test "template with  hostgroup should be rendered" do
+    get :template, {:id => "MyString", :hostgroup => "Common"}
+    assert_response :success
+  end
+
+  test "template with non-existant  hostgroup should not be rendered" do
+    get :template, {:id => "MyString2", :hostgroup => "NotArealHostgroup"}
+    assert_response :not_found
+  end
+
+ test "requesting a template that does not exist should fail" do
+    get :template, {:id => "kdsfjlkasjdfkl", :hostgroup => "Common"}
+    assert_response :not_found
+  end
+
+  test "hosts with unknown ip and valid token should render a template" do
+    Setting[:token_duration] = 30
+    @request.env["REMOTE_ADDR"] = '127.0.0.1'
+    hosts(:ubuntu).create_token(:value => "aaaaaa", :expires => Time.now + 5.minutes)
+    get :preseed, {'token' => hosts(:ubuntu).token.value }
+    assert_response :success
+  end
+
+  test "template should contain tokens when tokens enabled and present for the host" do
+    Setting[:token_duration] = 30
+    Setting[:foreman_url]    = "test.host"
+    @request.env["REMOTE_ADDR"] = hosts(:ubuntu).ip
+    hosts(:ubuntu).create_token(:value => "aaaaaa", :expires => Time.now + 5.minutes)
+    get :preseed
+    expected = File.read(Pathname.new(__FILE__).parent.parent + "fixtures/sample_tokenised_template")
+    assert_equal expected, @response.body
+  end
+
+  test "template should not contain https when ssl enabled" do
+    @request.env["HTTPS"] = "on"
+    @request.env["REMOTE_ADDR"] = hosts(:ubuntu).ip
+    get :preseed
+    expected = File.read(Pathname.new(__FILE__).parent.parent + "fixtures/sample_http_preseed_template")
+    # @response.body contains <head> and page header and footer and expected do not, which caused the test to fail if assert_equal
+    assert_equal expected, @response.body
+  end
+
+end

data/test/foreman_app/test/functional/usergroups_controller_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+
+class UsergroupsControllerTest < ActionController::TestCase
+  def test_index
+    get :index, {}, set_session_user
+    assert_template 'index'
+  end
+
+  def test_new
+    get :new, {}, set_session_user
+    assert_template 'new'
+  end
+
+  def test_create_invalid
+    Usergroup.any_instance.stubs(:valid?).returns(false)
+    post :create, {}, set_session_user
+    assert_template 'new'
+  end
+
+  def test_create_valid
+    Usergroup.any_instance.stubs(:valid?).returns(true)
+    post :create, {}, set_session_user
+    assert_redirected_to usergroups_url
+  end
+
+  def test_edit
+    get :edit, {:id => Usergroup.first}, set_session_user
+    assert_template 'edit'
+  end
+
+  def test_update_invalid
+    Usergroup.any_instance.stubs(:valid?).returns(false)
+    put :update, {:id => Usergroup.first, :usergroup => {:user_ids => ["",""], :usergroup_ids => ["",""]} }, set_session_user
+    assert_template 'edit'
+  end
+
+  def test_update_valid
+    Usergroup.any_instance.stubs(:valid?).returns(true)
+    put :update, {:id => Usergroup.first, :usergroup => {:user_ids => ["",""], :usergroup_ids => ["",""]} }, set_session_user
+    assert_redirected_to usergroups_url
+  end
+
+  def test_destroy
+    usergroup = Usergroup.first
+    delete :destroy, {:id => usergroup}, set_session_user
+    assert_redirected_to usergroups_url
+    assert !Usergroup.exists?(usergroup.id)
+  end
+
+  def setup_user
+    @request.session[:user] = users(:one).id
+    users(:one).roles       = [Role.find_by_name('Anonymous'), Role.find_by_name('Viewer')]
+  end
+
+  test 'user with viewer rights should fail to edit a usergroup' do
+    setup_user
+    get :edit, {:id => Usergroup.first.id}, set_session_user.merge(:user => users(:one).id)
+    assert_equal @response.status, 403
+  end
+
+  test 'user with viewer rights should succeed in viewing usergroups' do
+    setup_user
+    get :index, {}, set_session_user
+    assert_response :success
+  end
+end

data/test/foreman_app/test/functional/users_controller_test.rb

@@ -0,0 +1,147 @@
+require 'test_helper'
+
+class UsersControllerTest < ActionController::TestCase
+  def setup
+    setup_users
+  end
+
+  test "should get index" do
+    get :index, {}, set_session_user
+    assert_response :success
+  end
+
+  test "should get edit" do
+    u = User.new :login => "foo", :mail => "foo@bar.com", :auth_source => auth_sources(:one)
+    assert u.save!
+    logger.info "************ ID = #{u.id}"
+    get :edit, {:id => u.id}, set_session_user
+    assert_response :success
+  end
+
+  test "should update user" do
+    user = User.create :login => "foo", :mail => "foo@bar.com", :auth_source => auth_sources(:one)
+
+    put :update, { :commit => "Submit", :id => user.id, :user => {:login => "johnsmith"} }, set_session_user
+    mod_user = User.find_by_id(user.id)
+
+    assert mod_user.login == "johnsmith"
+    assert_redirected_to users_path
+  end
+
+  def test_one #"should not remove the anonymous role" do
+    user = User.create :login => "foo", :mail => "foo@bar.com", :auth_source => auth_sources(:one)
+
+    assert user.roles =([roles(:anonymous)])
+
+    put :update, { :commit => "Submit", :id => user.id, :user => {:login => "johnsmith"} }, set_session_user
+    mod_user = User.find_by_id(user.id)
+
+    assert mod_user.roles =([roles(:anonymous)])
+  end
+
+  test "should set password" do
+    user = User.new :login => "foo", :mail => "foo@bar.com", :firstname => "john", :lastname => "smith", :auth_source => auth_sources(:internal)
+    user.password = "changeme"
+    assert user.save
+
+    put :update, {:commit => "Submit", :id => user.id,
+                  :user => {
+                    :login => "johnsmith", :password => "dummy", :password_confirmation => "dummy"
+                  },
+                 }, set_session_user
+    mod_user = User.find_by_id(user.id)
+
+    assert mod_user.matching_password?("dummy")
+    assert_redirected_to users_path
+  end
+
+  test "should detect password validation mismatches" do
+    user = User.new :login => "foo", :mail => "foo@bar.com", :firstname => "john", :lastname => "smith", :auth_source => auth_sources(:internal)
+    user.password = "changeme"
+    assert user.save
+
+    put :update, {:commit => "Submit", :id => user.id,
+                  :user => {
+                    :login => "johnsmith", :password => "dummy", :password_confirmation => "DUMMY"
+                  },
+                 }, set_session_user
+    mod_user = User.find_by_id(user.id)
+
+    assert  mod_user.matching_password?("changeme")
+    assert_template :edit
+  end
+
+  test "should not ask for confirmation if no password is set" do
+    user = User.new :login => "foo", :mail => "foo@bar.com", :firstname => "john", :lastname => "smith", :auth_source => auth_sources(:internal)
+    user.password = "changeme"
+    assert user.save
+
+    put :update, {:commit => "Submit", :id => user.id,
+                  :user => { :login => "foobar" },
+                 }, set_session_user
+
+    assert_redirected_to users_url
+  end
+
+  test "should delete different user" do
+    user = users(:one)
+    delete :destroy, {:id => user}, set_session_user.merge(:user => users(:admin))
+    assert_redirected_to users_url
+    assert !User.exists?(user.id)
+  end
+
+  test "should not delete same user" do
+    return unless SETTINGS[:login]
+    @request.env['HTTP_REFERER'] = users_path
+    user = users(:one)
+    user.update_attribute :admin, true
+    delete :destroy, {:id => user.id}, set_session_user.merge(:user => user.id)
+    assert_redirected_to users_url
+    assert User.exists?(user)
+    assert @request.flash[:notice] == "You are currently logged in, suicidal?"
+  end
+
+  test "should recreate the admin account" do
+    return true unless SETTINGS[:login]
+    return true unless SETTINGS[:login] == false
+    User.admin.delete # Of course we only use destroy in the codebase
+    assert User.find_by_login("admin").nil?
+    get :index, {}, {:user => nil}
+    assert !User.find_by_login("admin").nil?
+  end
+
+  test 'user with viewer rights should fail to edit a user' do
+    get :edit, {:id => User.first.id}
+    assert_equal @response.status, 403
+  end
+
+  test 'user with viewer rights should succeed in viewing users' do
+    get :index
+    assert_response :success
+  end
+
+  test "should clear the current user after processing the request" do
+    get :index, {}, set_session_user
+    assert User.current.nil?
+  end
+
+  test "should set user as owner of hostgroup children if owner of hostgroup root" do
+    User.current = User.first
+    sample_user = users(:one)
+
+    Hostgroup.new(:name => "root").save
+    Hostgroup.new(:name => "first" , :parent_id => Hostgroup.find_by_name("root").id).save
+    Hostgroup.new(:name => "second", :parent_id => Hostgroup.find_by_name("first").id).save
+
+    update_hash = {"user"=>{ "login"         => sample_user.login,
+      "hostgroup_ids" => ["", Hostgroup.find_by_name("root").id.to_s] },
+      "commit"        => "Submit",
+      "id"            => sample_user.id }
+
+    put :update, update_hash , set_session_user
+
+    assert_equal Hostgroup.find_by_name("first").users.first , sample_user
+    assert_equal Hostgroup.find_by_name("second").users.first, sample_user
+  end
+
+end